Assertions en JavaScript

Question

Lire de manière approfondie sur les divers cadres d'assertion en JavaScript. Existe-t-il un type de bibliothèque/cadre «standard» de facto/le plus courant? En choisissant un - quels points méritent le plus d'être remarqués?

La seule exigence à laquelle je peux penser est une surcharge quasi-nulle en mode production.

Answer 1

Deux solutions possibles:

Demandez à votre script version build supprimer les lignes Assert.

ou

Demandez à votre script de compilation remplacer la fonction Assert il est donc juste une fonction vide. L'inconvénient de ceci est que si vous affirmez que l'appel a une logique dedans [alias assert (x> 100, "foo")] que cette logique [x> 100] va encore être exécutée.

Answer 2

Voici ce que j'utiliser:

Quand je travaille sur le code que j'ai initDevMode(); en haut du fichier avec lequel je travaille, et quand je suis prêt à sortir en production, je supprime juste cette ligne et toutes les assertions vont juste à une fonction vide.

/** 
* Log a message to console: 
* either use jquery's console.error 
* or a thrown exception. 
* 
* call initDevMode(); before use to activate 
* use with: 
*  assert(<condition>, "message"); 
*  eg: assert(1 != 1, "uh oh!"); 
* 
* Log errors with: 
*  errorLog(message); 
*  eg: errorLog(xhr.status); 
*/ 
assert = function(test, msg) { } 
errorLog =function(msg) { } 

initDevMode = function() { 
    assert = function(test, msg) { 
     msg = msg || "(no error message)"; 
     if(!test) { 
      try { 
        throw Error(); 
       } catch(e) { 
        var foo = e; 
        var lines = e.stack.split('\n'); 
        for(i in lines) { 
         if(i > 2) { 
         errorLog(msg + lines[i]); 
        } 
       } 
      } 
     } 
     throw("Assertion failed with: " + msg); 
    }; 
    errorLog = function(msg) { 
     if(typeof console.error == 'function') { 
      console.error(msg); 
     } else { 
      function errorLog(msg) { 
       console.log("foo"); 
       setTimeout(function() { 
        throw new Error(msg); 
       }, 0); 
      } 
     } 
    }; 
} 

Answer 3

Regardez Jascree; Fondamentalement, c'est un outil qui peut supprimer les assertions avec une logique presque arbitraire de votre code. C'est pratique à utiliser en tant que processeur par lots pour générer votre code de production ou pour un répertoire de scripts soutenu par fastcgi que vous pouvez utiliser lorsque vous avez besoin de tester les performances/profiler votre code.

Answer 4

J'utilise ce qui suit pour remplacer console.assert lorsqu'elle n'est pas disponible pour une raison quelconque.

Ce n'est certainement pas un standard de facto, et il est loin d'être idéal, mais il satisfait votre exigence que l'assertion ne soit pas évaluée en mode production. En outre, il vous montre l'expression qui a déclenché l'assertion échouée, ce qui facilite le débogage.

La syntaxe d'appel visqueuse (avec une expression de fonction) est là pour créer une fermeture, de sorte que la fonction assert a accès aux mêmes variables auxquelles son appelant a accès.

Je suppose que cela a un temps de compilation et d'exécution élevé, mais je n'ai pas essayé de le vérifier.

function assert(func) { 
    var name; 
    if (typeof(ENABLE_ASSERTIONS) !== "undefined" && !ENABLE_ASSERTIONS) { 
     return; 
    } 
    name = arguments.callee.caller; 
    name = name ? name.name : "(toplevel)"; 
    if (!func()) { 
     throw name + ": assertion failed: " + ('' + func).replace(/function[^(]*\([^)]*\)[^{]*{[^r]*return/, '').replace(/;[ \t\n]*}[ \t\n]*$/, ''); 
    } 
} 

Son utilisation ressemble:

function testAssertSuccess() { 
    var i = 1; 
    assert(function() { return i === 1; }); 
} 
function testAssertFailure() { 
    var j = 1; 
    assert(function() { return j === 2; }); 
} 
ENABLE_ASSERTIONS = true; 
testAssertSuccess(); 
testAssertFailure(); 

HTH!