Bien que les tableaux soient des objets en JavaScript, il n'y a pas de bonnes raisons d'utiliser la boucle [`for in`](#object.forinloop).

En fait, il un certain nombre de bonnes raisons **contre** l'utilisation de `for in` sur les tableaux.

**Remarque:** Les tableaux JavaScript ne sont **pas** *associatifs*. JavaScript n'offre que les [objets](#object.general) pour associer des clés à des valeurs. Contrairement aux tableaux associatifs, les objets ne préservent **pas** l'ordre.

La boucle `for in` énumère toutes les propriétés qui sont sur la chaîne de prototypes, et le seul moyen d'exclure ces propriétés consiste à utiliser

[`hasOwnProperty`](#object.hasownproperty), par conséquent la boucle `for in ` est **vingt fois** plus lente qu'une boucle `for` classique.

Pour itérer sur les tableaux de façon performante, il est préférable d'utiliser la boucle `for` classique.

var list = [1, 2, 3, 4, 5, ...... 100000000];

for(var i = 0, l = list.length; i < l; i++) {

console.log(list[i]);

}

Notez l'optimization supplémentaire dans l'exemple ci-dessus: la longueur du tableau est mise en mémoire "cached" via `l = list.length`.

La propriété `length` est définie sur le tableau lui-même, mais la rechercher à chaque itération de la boucle à un coût.

Bien que les moteurs JavaScript récents **peuvent** appliquer l'optimisation, il n'y a aucun moyen de savoir si le code s'exécutera sur un de ces nouveaux moteurs.

En effet, mettre la longueur du tableau en mémoire cache peut **doubler** la vitesse d'execution de la boucle.

Le *getter* de la propriété `length` (longueur) renvoie simplement le nombre d'éléments contenus dans le tableau, mais le *setter* peut être utilisé pour

tronquer le tableau.

var arr = [1, 2, 3, 4, 5, 6];

arr.length = 3;

arr; // [1, 2, 3]

arr.length = 6;

arr.push(4);

arr; // [1, 2, 3, undefined, undefined, undefined, 4]

Attribuer une longueur inférieure tronque le tableau. Accroître la longueur crée un tableau clairsemé.

Pour de meilleures performances, il est recommandé de toujours utiliser la boucle `for` classique et de mettre en mémoire la propriété `length`.

L'utilisation de la boucle `for in` sur un tableau est un signe de code mal écrit, de mauvaise performance, et sujet à des bogues.

Il est *impossible* de supprimer les variables globales, fonctions et autres choses qui ont l'attribut `DontDelete` en JavaScript.

Quand une variable ou une fonction est définie dans la portée globale ou une [portée de fonction](#function.scopes), c'est une propriété soit de l'objet d'activation, soit de l'objet global.

Ces propriétés ont un ensemble d'attributs, dont l'un est `DontDelete`. Les déclarations de variables et de fonctions dans le code global et le code de fonction vont toujours créer des propriétés avec `DontDelete`, elle ne peuvent donc pas être supprimées.

// global variable:

var a = 1; // DontDelete est mis

delete a; // faux

a; // 1

// normal function:

function f() {} // DontDelete is mis

delete f; // faux

typeof f; // "function"

// reassigner n'aide pas:

f = 1;

delete f; // faux

f; // 1

Les propriétés crées explicitement peuvent être supprimées normalement.

// propriété crée explicitement:

var obj = {x: 1};

obj.y = 2;

delete obj.x; // vrai

delete obj.y; // vrai

obj.x; // undefined

obj.y; // undefined

Dans l'exemple ci-dessus, les propriétés `obj.x` et `obj.y` peuvent être supprimées parce qu'elles n'ont pas l'attribut `DontDelete`. C'est aussi pourquoi l'exemple ci-dessous fonctionne également.

// ceci fonctionne, sauf sur IE:

var GLOBAL_OBJECT = this;

GLOBAL_OBJECT.a = 1;

a === GLOBAL_OBJECT.a; // vrai - juste une var globale

delete GLOBAL_OBJECT.a; // vrai

GLOBAL_OBJECT.a; // undefined

Ici, nous utilisons une astuce pour supprimer `a`. [`this`](#function.this) se réfère ici à l'objet global et nous déclarons explicitement la variable `a` comme sa propriété, ce qui nous permet de la supprimer.

IE (au moins 6-8) a quelques bogues, le code ci-dessus n'y fonctionne pas.

Les arguments normaux de fonctions, [objets `arguments`](#Function.arguments) et les propriétés intégrées "built-in" ont aussi l'attribut `DontDelete`.

// les arguments de fonction et les propriétés:

(function (x) {

delete arguments; // faux

typeof arguments; // "object"

delete x; // faux

x; // 1

function f(){}

delete f.length; // faux

typeof f.length; // "number"

})(1);

Le comportement de l'opérateur `delete` peut être imprévisible pour les objets hébergés "hosted". Dû à la spécification, les objets hôte sont autorisés à mettre en œuvre tout type de comportement.

L'opérateur `delete` a souvent un comportement inattendu et ne peut être utilisé que pour supprimer les propriétés explicitement définies sur des objets normaux.

La fonction `eval` exécute une chaîne de caractères représentant du code JavaScript dans la portée locale.

var number = 1;

function test() {

var number = 2;

eval('number = 3');

return number;

}

test(); // 3

number; // 1

Cependant, `eval` n'exécute dans la portée locale que quand il est appelé directement *et* quand le nom de la fonction appelée est en fait `eval`.

var number = 1;

function test() {

var number = 2;

var copyOfEval = eval;

copyOfEval('number = 3');

return number;

}

test(); // 2

number; // 3

L'utilisation de la fonction `eval` doit être évitée. 99,9% de ses "cas d'utilisation" peuvent être obtenues **sans** elle.

Les [fonctions timeout](#other.timeouts) `setTimeout` et `setInterval` acceptent une chaîne comme premier argument.

Cette chaîne sera **toujours** exécutée dans la portée globale car dans ce cas, `eval` n'est pas appelé directement.

`eval` est aussi un problème de sécurité, car il exécute **n'importe quel** code qu'on lui donne.

Il devrait **jamais** être utilisé avec des chaînes d'origines inconnues ou douteuses.

`eval` ne devrait jamais être utilisé. Sa presence met en doute le fonctionnement, la performance, et la sécurité du code qui l'utilise.

Si quelque chose a besoin d'`eval` pour pouvoir fonctionner, il ne doit **pas** être utilisé en premier lieu. Un *meilleur design* qui n'utilise pas `eval` doit être trouvé et implementé.

Bien que JavaScript a une syntaxe de style C, il n'impose **pas** les points-virgules dans le code source. Il est donc possible de les omettre.

JavaScript n'est pas un langage sans points-virgules. En fait, les points-virgules sont necessaires pour comprendre le code source. Par conséquent, l'analyseur JavaScript les insère **automatiquement** chaque fois qu'il rencontre une erreur d'analyse due à un point-virgule manquant.

var foo = function() {

} // erreur d'analyse, point-virgule attendu

test()

L'analyseur insère un point-virgule, puis tente à nouveau.

var foo = function() {

}; // plus d'error, l'analyse continue

test()

L'insertion automatique du point-virgule est considérée comme l'un des **plus gros** défauts de conception dans le langage parce que cela *peut* changer le comportement du code.

Le code ci-dessous n'a pas de points-virgules, l'analyseur va donc décider où les insérer.

(function(window, undefined) {

function test(options) {

log('testing!')

(options.list || []).forEach(function(i) {

})

options.value.test(

'long string to pass here',

'and another long string to pass'

)

return

{

foo: function() {}

}

}

window.test = test

})(window)

(function(window) {

window.someLibrary = {}

})(window)

Voici le résultat du jeu de devinette de l'analyseur.

(function(window, undefined) {

function test(options) {

// pas inséré, les lignes ont fusionné

log('testing!')(options.list || []).forEach(function(i) {

}); // <- inséré

options.value.test(

'long string to pass here',

'and another long string to pass'

); // <- inséré

return; // <- inséré, casse la déclaration return

{ // traité comme un bloc

// un label et une déclaration d'expression

foo: function() {}

}; // <- inséré

}

window.test = test; // <- inséré

// les lignes ont fusionné ici encore

})(window)(function(window) {

window.someLibrary = {}; // <- inséré

})(window); //<- inséré

L'analyseur a radicalement changé le comportement du code ci-dessus. Dans certains cas, il fait la **mauvaise chose**.

En cas de parenthèse en tête, l'analyseur ne va **pas** insérer de point-virgule.

log('testing!')

(options.list || []).forEach(function(i) {})

Ce code fusionne en une ligne.

log('testing!')(options.list || []).forEach(function(i) {})

Il y a de **très** fortes chances que `log` ne retourne **pas** de fonction; par conséquent, le programme ci-dessus va produire une erreur de type `TypeError` indiquant que undefined n'est pas un function `undefined is not a function`.

Il est fortement recommandé de ne **jamais** omettre les points-virgules. Il est également recommandé de garder les accolades sur la même ligne que leurs déclarations correspondantes et de ne jamais les omettre pour les déclaration en une ligne `if` / `else`. Ces mesures vont non seulement améliorer la cohérence du code, mais elles empêcheront également l'analyseur JavaScript de changer le comportement du code.

JavaScript a deux valeurs distinctes pour "rien": `null` et `undefined`, `undefined` étant la plus utile.

`undefined` est un type avec exactement une valeur:` undefined`.

Le langage définit également une variable globale qui a la valeur `undefined`. Cette variable est aussi appelée `undefined`. Cependant, cette variable n'est ni une constante, ni un mot clé du langage, ce que signifie que sa *valeur* peut être facilement écrasée.

Voici quelques exemples de cas où la valeur `undefined` est retournée:

- Accès à la variable globale (non modifié) `undefined`.

- Accès à une variable déclarée, mais *pas encore* initialisée.

- Retours implicites de fonctions sans déclaration `return`.

- Déclarations `return` vides, qui ne renvoient rien.

- Recherches de propriétés inexistantes.

- Paramètres de fonction qui ne ont pas de valeur explicite passée.

- Tout ce qui a été mis à la valeur de `undefined`.

- Toute expression sous forme de `void(expression)`.

Puisque la variable globale `undefined` contient uniquement une copie de la *valeur* réelle `undefined`, l'attribution d'une nouvelle valeur à la variable ne modifie **pas** la valeur du *type* `undefined`.

Pourtant, pour pouvoir comparer quelque chose contre la valeur de `undefined`, il est d'abord nécessaire pour récupérer la valeur de `undefined`.

Afin de protéger le code contre une éventuelle variable `undefined` écrasée, une technique commune utilisée consiste à ajouter un paramètre supplémentaire à une [enveloppe anonyme](#function.scopes) et de lui passer aucun argument.

var undefined = 123;

(function(something, foo, undefined) {

// undefined dans la portée locale

// réfère bien à la valeur `undefined`

})('Hello World', 42);

Une autre façon d'obtenir le même effet est d'utiliser une déclaration à l'intérieur de l'enveloppe.

var undefined = 123;

(function(something, foo) {

var undefined;

...

})('Hello World', 42);

La seule différence étant quelques caractères de plus pour écrire "var".

Alors que `undefined` dans le contexte du langage JavaScript est utilisé dans la plupart des cas dans le d'un *null* traditionnel, le `null` réel (un littéral et un type) est juste un autre type de données.

`null` est utilisé par JavaScript (comme signaler la fin de la chaîne de prototypes avec `Foo.prototype = null`), mais dans presque tous les cas, il peut être remplacé par `undefined`.