Phrases de lecture de base javascript

En JavaScript, les expressions sont des phrases et les déclarations sont la phrase ou la commande entière. Tout comme une déclaration anglaise se termine par une période, JavaScript se termine par un point-virgule.

L'expression calcule une valeur, mais l'instruction fait que quelque chose se passe.

Une façon de "faire quelque chose" est de calculer les expressions avec des effets secondaires. Les expressions avec des effets secondaires tels que les affectations et les appels de fonction peuvent être utilisés comme instructions distinctes. Cette utilisation des expressions comme instructions est également appelée instructions d'expression. Des instructions similaires incluent des instructions de déclaration, qui sont utilisées pour déclarer de nouvelles variables ou définir de nouvelles fonctions.

Un programme JavaScript est une collection d'une série de déclarations exécutables. Par défaut, l'interprète JavaScript est exécuté en séquence par ordre d'écriture. Une autre façon de "faire quelque chose" est de modifier l'ordre d'exécution par défaut de l'instruction:

1. Énoncé conditionnel: l'interprète JavaScript peut déterminer s'il faut exécuter ou sauter ces instructions, telles que les instructions SI et Switch.

2. Déclaration de Loop: Énoncés qui peuvent être exécutés à plusieurs reprises, tels que While et pour les déclarations

3. Déclaration de saut: vous pouvez laisser l'interprète sauter dans d'autres parties du programme pour continuer l'exécution, telles que les déclarations de pause, de retour et de lancer

Ensuite, cet article présentera diverses déclarations et leur syntaxe en JavaScript. Ce chapitre résume ces phrases à la fin. Un programme JavaScript n'est rien de plus qu'une collection d'instructions séparées par séparation, donc une fois que vous maîtrisez les instructions JavaScript, vous pouvez écrire un programme JavaScript.

1. Instruction d'expression

Les instructions d'attribution sont une déclaration d'expression relativement importante. Leur fonction est de modifier la valeur d'une variable, tout comme l'exécution d'une instruction d'affectation: par exemple

La copie de code est la suivante:

saluer = "bonjour" + nom;

i * = 3;

L'opérateur d'incrément (++) et l'opérateur décroissant (-) sont liés à l'instruction d'affectation. Leur fonction est de modifier la valeur d'une variable, tout comme l'exécution d'une instruction d'affectation.

La copie de code est la suivante:

compteur ++;

La fonction importante de l'opérateur de suppression est de supprimer les propriétés (ou les éléments d'un tableau) et tout ce qu'il est généralement utilisé comme instructions, et non dans le cadre d'une expression complexe.

La copie de code est la suivante:

supprimer le bœuf;

Les appels de fonction sont une autre catégorie majeure d'instructions d'expression, par exemple

La copie de code est la suivante:

alerte (saluer);

window.close ();

Bien que ces fonctions du client soient des expressions, elles ont un certain impact sur le navigateur Web. Nous pensons donc que c'est aussi une déclaration, et il n'est pas logique d'appeler une fonction sans effets secondaires à moins qu'il ne fasse partie d'une expression complexe ou d'une instruction d'affectation, par exemple. Il est impossible de jeter une valeur de cosinus au hasard;

Math.cos (x);

Au lieu de cela, pour obtenir la valeur du cosinus, vous devez l'attribuer à une variable afin que cette valeur puisse être utilisée à l'avenir:

var cx = math.cos (x);

Encore une fois, chaque ligne de code se termine par un point-virgule.

2. Énoncés composés et déclarations vides

Plusieurs expressions peuvent être concaténées avec un opérateur de virgule pour former une expression. De même, JavaScript peut également vous dire que plusieurs instructions sont unies ensemble pour former une instruction composée. Enveloppez simplement plusieurs instructions en accolades bouclées. Par conséquent, les lignes de code suivantes peuvent être utilisées comme instruction distincte n'importe où dans JavaScript, vous souhaitez utiliser une instruction.

La copie de code est la suivante:

{

x = math.pi;

cx = math.cos (x);

console.log ("cos (π) =" + cx);

}

Il y a plusieurs points à noter sur les blocs d'instructions: Premièrement, les blocs d'instruction ne nécessitent pas de demi-colons. Les instructions des éléments dans les blocs doivent se terminer avec des demi-colons, mais les blocs d'instruction ne le font pas.

Deuxièmement, les lignes du bloc de déclaration sont en retrait, ce qui n'est pas nécessaire, mais une indentation soignée peut rendre le code plus lisible et plus facile à comprendre.

Troisièmement, JavaScript n'a pas de portée au niveau du bloc, et les variables déclarées dans le bloc d'instruction ne sont pas privées par le bloc d'instructions. (Reportez-vous à la première section du chapitre 3, 10)

La pratique de la combinaison de nombreuses déclarations dans un grand bloc de déclaration est très courante dans la programmation JavaScript. Des expressions similaires contiennent généralement des sous-expressions, de nombreux javascripts contiennent d'autres substances. En termes de forme, JavaScript permet généralement à un bloc d'instruction de contenir une substitution. Par exemple: le corps de boucle while ne peut contenir qu'une seule instruction. À l'aide d'un bloc d'instructions, vous pouvez mettre n'importe quel nombre d'instructions dans ce bloc, et ce bloc d'instruction peut être utilisé comme instruction.

Dans JavaScript, lorsque vous souhaitez que plusieurs instructions soient utilisées comme une instruction, utilisez à la place une instruction conforme. Une instruction vide (instruction vide) est exactement le contraire, il permet de contenir 0 instructions. La déclaration vide ressemble à ceci:

; // Semicolon

L'interprète JavaScript n'effectue évidemment aucune action lors de l'exécution d'une déclaration vide, mais la pratique a prouvé que les instructions vides sont parfois utiles lors de la création d'une boucle avec un corps de boucle vide, comme ce qui suit pour la boucle

La copie de code est la suivante:

// initialise un tableau un

for (i = 0; i <a.length; a [i ++] = 0);

Dans cette boucle, toutes les opérations sont terminées dans l'expression a [i ++] = 0, et aucun corps de boucle n'est nécessaire ici. Cependant, JavaScript exige que le corps de boucle contient au moins une instruction, donc seul un demi-point de demi-colon est utilisé ici pour représenter une instruction vide.

Notez que les demi-colons dans le côté droit de la boucle pour la boucle, tandis que la boucle ou la déclaration IF sont discrets, ce qui peut provoquer des bogues mortels, difficiles à localiser. Par exemple, le résultat d'exécution du code suivant est probablement un effet que l'auteur ne veut pas:

La copie de code est la suivante:

if ((a == 0) || (b == 0)); // Cette ligne de code ne fait rien ...

o = null; // Cette ligne de code sera toujours exécutée

Si vous utilisez une instruction vide à des fins spéciales, il est préférable d'ajouter des commentaires dans le code, ce qui peut clairement indiquer que cette instruction vide est utile.

La copie de code est la suivante:

pour (i = 0; i <a.length; a [i ++] = 0) / * vide * /;

3. Déclaration de déclaration

La VAR et la fonction sont des instructions de déclaration qui déclarent ou définissent des variables ou des fonctions. Ces instructions définissent et affectent des identificateurs (noms de variables et noms de fonction), qui peuvent être utilisés n'importe où dans le programme. Les déclarations de déclaration ne font rien elles-mêmes, mais elle a une signification importante: en créant des variables et des fonctions, la sémantique du code peut être mieux organisée.

Les sections suivantes parleront des instructions VAR et des instructions de fonction, mais ne contiennent pas tous les contenus des variables et des fonctions.

i.var

L'instruction VAR est utilisée pour déclarer une ou plusieurs variables. Sa syntaxe est la suivante:

var name_1 [= valeur_1] [, ..., name_n [= valeur_n]]

Le mot-clé var est suivi d'une liste de variables à déclarer. Chaque variable de la liste peut avoir une expression d'initialisation qui peut être utilisée pour spécifier sa valeur initiale. Par exemple:

La copie de code est la suivante:

var i; // une variable simple

var j = 0; // une variable avec une valeur initiale

var p, q; // deux variables

var salut = "hello" + name; // Expression d'initialisation plus complexe

var x = 2,34, y = math.cos (0,75), r, thêta; // de nombreuses variables

var x = 2, y = x * x; // La deuxième variable utilise la première variable

var x = 2,

f = fonction (x) {return x * x}, // chaque variable a une exclusivité en ligne

y = f (x)

Si l'instruction VAR apparaît dans le corps de la fonction, il définit une variable locale et que sa portée est cette fonction. Si vous utilisez une instruction VAR dans le code de niveau supérieur, il déclare une variable globale, qui est visible à travers JavaScript. Dans le chapitre 3, section 10, il est mentionné que les variables globales sont des propriétés des objets globaux. Ensuite, contrairement à d'autres propriétés d'objets globales, les variables déclarées par VAR ne peuvent pas être supprimées via Delete.

Si la variable de l'instruction VAR ne spécifie pas d'expression d'initialisation, la valeur de cette variable n'est initialement pas définie. Par conséquent, la valeur de la variable avant l'instruction de déclaration n'est pas définie.

Il convient de noter que l'instruction VAR peut également être utilisée comme composant de la boucle FOR ou pour / en boucle. (Identique aux déclarations variables déclarées avant les boucles, les variables déclarées ici seront également "avancées"), par exemple:

La copie de code est la suivante:

pour (var i = 0; i <10; i ++) console.log (i);

pour (var i = 0, j = 10; i <10; i ++, j--) console.log (i * j);

pour (var i in o) console.log (i);

Notez que peu importe si vous déclarez la même variable plusieurs fois.

ii.

La fonction de mot-clé est utilisée pour déclarer les fonctions. Nous avons appris les expressions de fonction (4.3). Les définitions de fonction peuvent être écrites en une forme d'une instruction. Par exemple: deux définitions sont écrites dans l'exemple de code suivant:

La copie de code est la suivante:

var f = fonction f (x) {return x + 1;} // attribue l'expression à une variable

fonction f (x) {return x + 1;} // phrase contenant des noms de variables

La déclaration de syntaxe de fonction est la suivante:

La copie de code est la suivante:

fonction funcname ([arg1 [, arg2 [..., argn]]]) {

affirmations

}

FuncName est l'identifiant de nom de la fonction à déclarer. Le nom de la fonction est suivi de la liste des paramètres, séparée par des virgules. Lors de l'appel d'une fonction, ces identifiants se réfèrent aux paramètres réels transmis à la fonction.

Le corps de fonction est composé d'instructions JavaScript, sans limite sur le nombre d'instructions et est enfermée en accolades bouclées. Lors de la définition d'une fonction, les instructions du corps de fonction ne sont pas exécutées, mais sont associées à l'exécution du nouvel objet de fonction lors de l'appel de la fonction. Notez que les accolades bouclées dans les instructions de fonction de fonction sont nécessaires, ce qui est différent des blocs d'instructions utilisés par des boucles et d'autres verrous d'instructions. Même si le corps de fonction n'a qu'une seule instruction, des accolades bouclées sont toujours nécessaires pour le conclure.

La copie de code est la suivante:

fonction hyteus (x, y) {

return math.sqrt (x * x + y * y);

}

Hyteus (1, 2) //=>2.23606797749979

fonction faciale (n) {// une fonction récursive

if (n <= 1) return 1;

retour n * facial (n - 1);

}

facial (11) // => 39916800

Les déclarations de fonction apparaissent généralement en haut du code JavaScript et peuvent également être imbriquées dans d'autres fonctions. Mais lorsqu'ils sont imbriqués, les déclarations de fonction ne peuvent apparaître qu'en haut de la fonction imbriquée. C'est-à-dire: la définition de la fonction ne peut pas apparaître dans si, what ou d'autres instructions.

Comme l'instruction VAR, les variables créées par les instructions de déclaration de fonction ne peuvent pas être supprimées. Cependant, ces variables ne sont pas en lecture seule et les valeurs variables peuvent être réécrites.

4. Énoncés conditionnels

Une instruction conditionnelle consiste à exécuter ou à sauter certaines instructions en déterminant si la valeur de l'expression spécifiée doit être évaluée. Ces déclarations sont des "points de décision" du code, parfois appelés "branches". Si l'interpréteur JavaScript est exécuté en suivant le "chemin" du code. L'énoncé conditionnel est le point de fourche sur ce chemin. Lorsque le programme atteint ce point, vous devez sélectionner un chemin pour continuer l'exécution.

I.IF Déclaration

Si l'instruction est une instruction de contrôle de base. Pour être précis, il permet au programme d'exécuter conditionnellement. Il existe deux formes de cette déclaration: la première est

La copie de code est la suivante:

si (expression)

déclaration

Dans cette forme, si la valeur de l'expression est vraie, exécutez l'instruction de l'instruction et si elle est fausse, n'exécutez pas l'instruction. Par exemple,

La copie de code est la suivante:

if (nom d'utilisateur == null) // si le nom d'utilisateur est nul ou indéfini

username = "Jack Wong"; // Définissez-le

Il convient de noter qu'il est nécessaire de renfermer les supports de jardin de la déclaration d'expression.

La syntaxe JavaScript stipule que si les mots clés et les expressions avec pare-jardinage doivent être suivis d'une déclaration. Cependant, plusieurs instructions peuvent être combinées en une à l'aide de blocs d'instructions. Par conséquent, la forme de l'instruction IF ressemble à ceci:

La copie de code est la suivante:

if (! adresse) {

adresse = "";

Message = "S'il vous plaît Adresse postale"

}

La deuxième forme de l'instruction if introduit la clause ELSE et exécute la logique else lorsque la valeur de l'expression est fausse.

La copie de code est la suivante:

si (expression)

déclaration 1

autre

déclaration2

Par exemple, le code suivant

La copie de code est la suivante:

si (n == 1)

console.log ("1 nouveau message");

autre

console.log ("vous avez" + n + "nouveau message");

Lorsque vous utilisez des instructions if / else dans les instructions IFF nichés, vous devez veiller à vous assurer que l'instruction ELSE correspond à l'instruction IFROCTRÉE. Considérez le code suivant:

La copie de code est la suivante:

i = j = 1;

k = 2;

si (i == j)

if (j == k)

console.log ("i est égal à K");

autre

console.log ("i dosent égal j"); //Erreur! !

Dans cet exemple, l'instruction IF intérieure constitue les clauses requises par l'instruction IFT extérieure. Cependant, la relation de correspondance entre IF et Else n'est pas claire (seule l'indentation donne un petit indice) et dans cet exemple, l'indice indiqué par l'indentation est mauvais, car l'interprète JavaScript le comprend.

La copie de code est la suivante:

if (i == j) {

if (j == k)

console.log ("i est égal à K");

autre

console.log ("i dosent égal j");

}

Comme la plupart des langages de programmation, les règles IF et ELONE correspondent à JavaScript qui correspondent toujours à l'instruction IF à proximité. Afin de rendre l'exemple lisible, plus facile à comprendre et plus pratique pour la maintenance et le débogage, des accolades bouclées doivent être utilisées.

La copie de code est la suivante:

if (i == j) {

if (j == k) {

console.log ("i est égal à K");

} else {// Les accolades de crape rendent le résultat du code plus clair

console.log ("i dosent égal j");

}

}

De nombreux programmeurs ont l'habitude de renfermer le corps des déclarations If et Else en orthèse bouclée (comme dans une déclaration correspondante comme une boucle de temps). Même s'il n'y a qu'une seule déclaration par branche, cela peut éviter le problème ambigu du programme tout à l'heure.

ii.else si

L'instruction if / else sélectionne l'une des deux branches en jugeant le résultat du calcul d'une expression. Que dois-je faire lorsqu'il y a beaucoup de branches dans le code? Une solution consiste à utiliser l'instruction ELSE IF. Sinon, si ce n'est pas une véritable instruction JavaScript, c'est juste un moyen d'écrire plusieurs instructions si / else.

La copie de code est la suivante:

if (n == 1) {

// Exécuter le bloc de code 1

} else if (n == 2) {

// Exécuter le bloc de code 2

} else if (n == 3) {

// Exécuter le bloc de code 3

} autre {

// Les conditions précédentes sont fausses, puis le bloc de code 4 est exécuté

}

Il n'y a rien de spécial dans ce type de code. Il se compose de plusieurs instructions IF, et chaque clause de relevé IF en contient une autre instruction IF. Le code équivalent de syntaxe peut être complété en utilisant la forme imbriquée des instructions IF, mais par rapport à cela, il est évident que l'écriture d'autre est plus claire et préférable.

iii.switch

Pendant l'exécution du programme, une instruction IF crée une branche et peut utiliser d'autre si pour gérer plusieurs branches. Ensuite, lorsque toutes les branches dépendent de la valeur de la même expression, sinon n'est pas la meilleure solution. Dans ce cas, il est très gaspillé de calculer à plusieurs reprises les expressions dans plusieurs déclarations.

L'instruction Switch convient à la gestion de cette situation. L'interrupteur de mots clés est suivi d'une expression entourée dans les parenthèses de jardin. Ensuite, il y a des blocs de code enfermés en accolades bouclées.

La copie de code est la suivante:

switch (expression) {

affirmations

}

Cependant, la syntaxe complète de l'instruction Switch est plus compliquée que cela. Le cas est suivi d'une expression et d'un côlon. L'affaire est très similaire à une langue de balisage, sauf que cette langue de balisage n'a pas de nom.

Il n'est associé qu'aux expressions qui le suivent. Lors de l'exécution de cette instruction Switch, il calcule d'abord la valeur de l'expression, puis découvre si l'expression de la clause de cas est la même que la valeur de l'expression. (La même chose est comparée à l'opérateur "==="). Si le cas est apparié, il exécutera le code correspondant. Si un cas correspondant ne peut être trouvé, il exécutera le bloc de code dans la balise "par défaut:". S'il n'y a pas de "par défaut:" TAG, Switch ignorera tous les blocs de code.

L'instruction Switch est très facile à confondre, et l'introduction avec des exemples sera plus claire. L'instruction Switch suivante est équivalente à l'instruction if / else tout à l'heure.

La copie de code est la suivante:

commutateur (n) {

Cas 1: // Si n === 1 commence à partir d'ici

// Exécuter le bloc de code 1

casser;

Cas 2:

// Exécuter le bloc de code 2

casser;

Cas 3:

// Exécuter le bloc de code 3

casser;

défaut:

// Exécuter le bloc de code 4

casser;

}

Il convient de noter que la rupture du mot-clé est utilisée à la fin de chaque instruction de cas. Nous présenterons la déclaration de pause plus tard. L'instruction Break peut faire sauter l'interprète de l'instruction Switch ou l'instruction LOOP. Dans Switch, le cas indique uniquement le point de départ du code à exécuter, mais ne spécifie pas le point final. S'il n'y a pas d'instruction de rupture, l'instruction Switch commence à s'exécuter à partir du code à la balise de cas de correspondance de la valeur d'expression et exécute des instructions ultérieures à son tour jusqu'à la fin du bloc de code de commutation entier. Bien sûr, si vous utilisez une instruction Switch dans une fonction, vous pouvez utiliser Retour pour remplacer la pause. Le retour et la rupture sont tous deux utilisés pour résilier l'instruction Switch, qui empêchera également une instruction de cas de continuer à exécuter le bloc de relevé de cas suivant.

L'instruction suivante est proche du combat réel, et il convertit la valeur en une chaîne en fonction du type de valeur.

La copie de code est la suivante:

fonction convert (x) {

commutateur (typeof x) {

Cas «numéro»: // convertir les nombres en hexadécimal

retour x.tostring (16);

case 'String':

return '"' + x + '"'; // retourne deux chaînes avec des citations doubles.

par défaut: // Utiliser des méthodes ordinaires pour convertir d'autres types

Retour String (x);

}

}

console.log (converti (100255114)) // => 5f9c58a

Notez que dans les deux exemples ci-dessus, le mot-clé du cas est suivi d'un nombre direct et d'une chaîne, qui est l'utilisation la plus courante de Switch dans la pratique, mais la norme ECMAScript permet à chaque mot-clé de suivre les expressions arbitraires.

L'instruction Switch calcule d'abord l'expression après le mot clé du commutateur, puis calcule l'expression après chaque cas dans l'ordre de haut en bas, sachant que la valeur de l'expression exécutée au cas et la valeur de l'expression du commutateur sont égales. Étant donné que l'opération de correspondance pour chaque cas est en fait une comparaison de l'opérateur d'identité "===", et non "==", la correspondance de l'expression et du cas ne fait aucune conversion de type.

Chaque fois qu'une instruction Switch est exécutée, toutes les expressions de cas ne peuvent pas être exécutées. Par conséquent, les expressions de cas avec des effets secondaires doivent être évitées, telles que les expressions d'appel de fonction et les expressions d'affectation. Le moyen le plus sûr est d'utiliser des expressions constantes dans le cas des expressions.

Comme mentionné précédemment, si l'expression du commutateur ne correspond pas à toutes les expressions de cas, le bloc d'instructions marqué "par défaut:" sera exécuté. S'il n'y a pas de balise "par défaut:", toute l'instruction Switch sera ignorée. Dans l'exemple précédent, la balise "par défaut:" apparaît à la fin du commutateur et est derrière toutes les balises de cas. Bien sûr, c'est la façon la plus raisonnable et le plus couramment utilisée. En fait, la balise "par défaut:" peut être placée n'importe où dans l'instruction Switch.

5. Boucle.

Pour comprendre les instructions conditionnelles, vous pouvez considérer le code en JavaScript comme chemin de branche. Les instructions de bouclage sont des instructions en boucle qui permettent à une exécution de code à plusieurs reprises. Il y a quatre instructions de boucle en javascript: tandis que, faire / while, pour et pour / in. Les sections suivantes les expliqueront tout de suite. La boucle la plus couramment utilisée est la traversée des éléments du tableau. (7.6 discutera de cette boucle et des méthodes de boucle spéciale définies par les classes de tableau en détail.)

I. En ce qui concerne

Si l'instruction est une instruction de contrôle de base utilisée pour sélectionner les instructions de branche qui exécutent le programme. Comme si, l'instruction while est également une instruction de boucle de base, et sa syntaxe est la suivante:

La copie de code est la suivante:

Tandis que (expression)

déclaration

Avant d'exécuter une instruction W SIT, l'interprète JavaScript calcule d'abord la valeur de l'expression. Si sa valeur est une fausse valeur, le programme sautera l'instruction logique dans le corps de la boucle et exécutera l'instruction suivante du programme. Si sa valeur est vraie, alors la logique dans l'instruction BOOP BORGE est exécutée, puis la valeur de l'expression de l'expression est calculée. La boucle se poursuivra jusqu'à ce que la valeur de l'expression soit fausse. En d'autres termes, lorsque l'expression est vraie, l'instruction sera exécutée dans une boucle. Notez que l'utilisation de while (true) créera une boucle morte.

D'une manière générale, nous ne voulons pas que JavaScript effectue la même opération à plusieurs reprises. Dans presque toutes les boucles, une ou plusieurs variables changeront de manière itérative avec la boucle. C'est précisément parce que ces variables sont modifiées que les opérations d'énoncé effectuées dans chaque boucle sont différentes. De plus, si la modification de la variable est utilisée dans l'expression, la valeur de l'expression de chaque boucle est également différente. C'est très important. L'expression responsable de la valeur initiale de la valeur réelle est toujours la valeur réelle, et la boucle ne se terminera pas. L'exemple ci-dessous montre que tandis que la boucle sort des valeurs 0-9.

La copie de code est la suivante:

Var Count = 0;

tandis que (compter <10) {

console.log (count);

Count ++;

}

On peut constater que dans cet exemple, la valeur initiale du nombre de variables est de 0, et pendant la boucle, sa valeur est incrémentée de 1 à chaque fois, lorsque la boucle est exécutée dix fois. La valeur de l'expression est programmée fausse, puis pendant la fin, et l'interprète JavaScript exécutera la prochaine instruction du programme. La plupart des boucles ont une variable de compteur comme le nombre. Bien que les compteurs utilisent souvent des noms de variables comme IJK, si vous souhaitez rendre le code plus lisible, vous devez utiliser des noms de syntaxe plus spécifiques.

ii.do/

La boucle do / while est très similaire à la boucle while, sauf qu'elle détecte l'expression de la boucle à la queue de la boucle plutôt qu'en haut, ce qui signifie que le corps de boucle est exécuté au moins une fois. La syntaxe de la boucle do / while est la suivante:

La copie de code est la suivante:

faire

déclaration

tandis que (expression);

Do / while les boucles ne sont pas aussi couramment utilisées que pendant que les boucles. En effet, il n'est pas courant dans la pratique de vouloir exécuter des boucles au moins une fois. Voici un exemple de boucle do / while

La copie de code est la suivante:

fonction printArray (a) {

var len = a.length,

i = 0;

if (len == 0)

console.log ("Array vide");

autre

faire {

console.log (a [i]);

} while (++ i <len);

}

PrintArray ([1,5,2,6])

Il existe deux différences de syntaxe entre les boucles DO / while et les boucles normales. Premièrement, la boucle DO nécessite que le mot clé DO doit être utilisé pour identifier le début de la boucle, utiliser lorsqu'il est variable pour identifier la fin de la boucle et entrer dans la condition de boucle pour juger; Deuxièmement, contrairement à la boucle while, la boucle Do utilise une fin semi-colonne. Si le corps de boucle while est enfermé en accolades bouclées, la boucle while ne se termine pas par un point-virgule.

iii. pour

L'instruction FOR fournit une structure de contrôle de déclaration de boucle plus pratique que pendant que. L'instruction FOR simplifie le mode de boucle couramment utilisé. La plupart des boucles ont des variables de comptoir spécifiques. Cette variable est initialisée avant le début de la boucle, puis vérifiez sa valeur avant chaque boucle. Enfin, la variable de comptoir est auto-incrémentée, sinon elle sera modifiée après la fin du cycle et avant le jugement suivant. Dans ce type de boucle, les trois opérations clés du compteur sont l'initialisation, la détection et la mise à jour. L'instruction FOR déclare explicitement ces trois opérations dans le cadre de la syntaxe de boucle, chacune utilisant une expression pour la représenter. La syntaxe de l'instruction FOR est la suivante:

La copie de code est la suivante:

pour (initialiser; test; incrément)

déclaration

Les trois expressions d'initialisation, de test et d'incrément sont séparées par des demi-colons. Ils sont responsables de l'initialisation des opérations, du jugement de la condition cyclique et de la mise à jour des variables de contre-les contre-lessières. Les placer sur la première ligne de la boucle facilite la compréhension de ce que fait la boucle For, et empêche également l'oublier d'initialiser ou d'incrémenter la variable de comptoir.

La façon la plus simple d'expliquer comment fonctionne une boucle pour la répertorié un équivalent en boucle

La copie de code est la suivante:

initialiser

while (test) {

déclaration

incrément;

}

En d'autres termes, l'expression initialisée n'est exécutée qu'une seule fois avant le début de la boucle. L'expression d'initialisation doit avoir des effets secondaires (généralement une instruction d'attribution). JavaScript permet également des expressions d'initialisation avec des instructions de déclaration de variable VAR, de sorte qu'une variable peut être déclarée et initialisée. Avant chaque boucle, l'expression du test sera exécutée et le résultat de l'expression sera jugé pour déterminer s'il faut exécuter le corps de la boucle. Avant chaque boucle, l'expression de test sera exécutée et le résultat sera déterminé si le corps de boucle sera exécuté. Si le résultat du test est la vraie valeur, l'instruction dans le corps de la boucle sera exécutée. Enfin, exécutez l'expression d'incrément. De plus, par souci d'utilité, l'expression d'incrément doit également avoir des effets secondaires. D'une manière générale, il s'agit d'une expression d'attribution ou d'une expression composée d'opérateurs "++" et "-".

La boucle ci-dessus peut être écrite en utilisant une boucle pour

La copie de code est la suivante:

pour (Var Count = 0; Count <10; Count ++)

Console.log (Count)

Bien sûr, certaines boucles sont plus complexes et plusieurs variables sont itérées à la fois dans la boucle. Dans JavaScript, ce cas doit être utilisé avec un opérateur de virgule, qui combine l'expression d'initialisation et l'expression de mise en œuvre en une seule expression à utiliser dans A pour la boucle.

La copie de code est la suivante:

var i, j;

pour (i = 0, j = 10; i <10; i ++, j--)

console.log (i * j);

Jusqu'à présent, les variables de boucle dans l'exemple de code sont tous des nombres. Bien sûr, les chiffres sont les plus couramment utilisés, mais pas nécessaires. Le code suivant utilise une boucle pour parcourir les résultats des données de la table et renvoyer le dernier objet dans la liste liée (c'est-à-dire le premier objet qui ne contient pas l'attribut suivant)

La copie de code est la suivante:

fonction de fonction (o) {// renvoie le dernier objet de nœud de la liste liée

for (; o.next; o = o.next) / * vide * / // exécuter la traversée en fonction de la question de savoir si O.Next est la vraie valeur

retour o;

}

Il convient de noter que ce code ne contient pas d'expressions d'initialisation, et les personnes et l'une des trois expressions dans la boucle FOR peuvent être ignorées, mais deux demi-colons sont indispensables. Si l'expression du test est omise, ce sera une boucle morte. Aussi avec le type while (ture), une façon d'écrire une boucle morte est pour (;;).

iiii.for / in

L'instruction FOR / IN utilise le mot-clé FOR, mais c'est un type de boucle différent de celui de la boucle régulière. La syntaxe de la boucle For / In est la suivante

La copie de code est la suivante:

pour (variable dans l'objet)

déclaration

Une variable est généralement un nom de variable ou une expression qui peut produire des LVAlues ou une variable déclarée via une instruction VAR. Quoi qu'il en soit, c'est une valeur qui s'applique au côté gauche de l'expression de l'affectation. L'objet est une expression, et le résultat de cette expression est un objet. De même, une déclaration est une déclaration ou un bloc d'énoncés qui forment le corps de la boucle.

L'utilisation d'une boucle pour itérater à travers les éléments du tableau est très simple

La copie de code est la suivante:

var a = [1, 3, 5, "44"];

for (var i = 0; i <a.length; i ++) // i représente l'index des éléments du tableau

console.log (a [i]) // des éléments de sortie de chaque tableau

La boucle For / In est utilisée pour traverser facilement les propriétés des membres de l'objet

La copie de code est la suivante:

for (var p in o) // attribue le nom de l'attribut à la variable p

console.log (o [p]); // Sortie de la valeur de chaque attribut

Dans le processus d'exécution de l'instruction FOR / IN, l'interprète JavaScript calcule d'abord l'expression de l'objet. Si l'expression est nul ou non définie, l'interpréteur JavaScript sautera la boucle et exécutera le code ultérieur. Si l'expression est égale à une valeur primitive, cette valeur primitive sera convertie en l'objet wrapper (section 3.6). Sinon, l'expression elle-même est déjà un objet. JavaScript énumère les propriétés de l'objet à son tour pour exécuter la boucle. Cependant, avant chaque boucle, JavaScript calcule la valeur de l'expression de la variable et y attribue le nom d'attribut (une chaîne).

Il convient de noter que tant que la boucle FOR / In / dans la valeur de Varibale peut être considérée comme la LVALUE de l'expression de l'affectation, et il peut être n'importe quelle expression. Cette expression est calculée chaque boucle, ce qui signifie que la valeur qu'il calcule peut être différente à chaque fois qu'elle boucle. Par exemple, vous pouvez utiliser le code suivant pour copier toutes les propriétés d'objets dans un tableau:

La copie de code est la suivante:

var o = {x: 1, y: 2, z: 3};

var a = [], i = 0;

pour (a [i ++] dans o) / * vide * /;

document.write (a) // => x, y, z

Les tableaux JavaScript ne sont que des objets spéciaux, donc la boucle FOR / In peut énumérer les index de données comme l'énumération des propriétés d'objets. Par exemple, l'ajout de ce code après le code ci-dessus peut énumérer l'index de données 0, 1, 2:

La copie de code est la suivante:

var o = {x: 1, y: 2, z: 3};

var a = [], i = 0;

pour (a [i ++] dans o) / * vide * /;

document.write (a) // => x, y, z copier les propriétés des objets dans un tableau

pour (je en a)

Document.Write (i) // => Enum Data Index 0 1 2

En fait, la boucle FOR / In ne traverse pas toutes les propriétés de l'objet. Seuls les attributs "énumérables" seront traversés (voir 6.7). Étant donné que les méthodes intégrées définies par le noyau de langue JavaScript ne sont pas "énumérables". Par exemple, tous les objets ont toString (), mais la boucle for / in ne énumére pas la propriété toString (). En plus des méthodes intégrées, il existe de nombreux objets intégrés qui ne sont pas énumérés. Tous les attributs et méthodes définis dans le code sont énumérables (la section 6.7 sera mentionnée, mais il existe des moyens particuliers dans ECMAScript5 qui peuvent rendre les attributs non énumérés).

Les objets peuvent hériter des propriétés d'autres objets, et la ligne hérite des propriétés personnalisées (6.2.ii) peut également être énumérée en utilisant pour / in.

Si le corps de boucle pour / en supprime une propriété non énumérée, cette propriété ne sera plus énumérée. Si le corps de boucle définit de nouvelles propriétés de l'objet, ces propriétés ne sont généralement pas énumérées (mais certaines implémentations de JavaScript peuvent énumérer les propriétés ajoutées dans le corps de la boucle).

L'ordre de l'énumération des attributs

La spécification ECMAScript ne spécifie pas dans laquelle l'ordre pour / en boucle énumère les propriétés de l'objet. Mais en fait, le fabricant du navigateur grand public JavaScript implémentation énumère les propriétés des objets simples dans l'ordre des définitions d'attribut, et les propriétés définies en premier sont énumérées en premier. Si un objet est créé sous la forme d'une quantité directe, il sera énuméré dans l'ordre dans lequel les propriétés en quantité directe apparaissent. (Certaines bibliothèques réseau et JavaScript s'appuient sur cet ordre d'énumération, tandis que les fabricants de navigateurs ne modifient principalement pas cet ordre). Dans les cas suivants, l'ordre d'énumération dépend de la mise en œuvre spécifique (pas d'interaction)

1. Les objets héritent des attributs énumérés

2. L'objet a des propriétés d'index de tableau entier

3. Utilisez la suppression pour supprimer les propriétés existantes de l'objet

4. Utilisez objet.defineProperty () ou des méthodes similaires pour modifier les propriétés de l'objet

6. Sauter

Dans JavaScript, un type d'instruction est une instruction JUMP. D'une compréhension d'une déclaration, il peut faire passer l'exécution de JavaScript d'une position à une position.

L'énoncé de pause consiste à sauter à la fin d'une boucle ou d'une autre déclaration. L'instruction CONSTANT met fin à l'exécution de cette boucle et démarre l'exécution de la boucle suivante. Les instructions dans JavaScript peuvent être nommées ou étiquetées, casser et continuer peuvent identifier les boucles cibles ou d'autres balises d'instruction.

L'instruction de retour permet à l'interpréteur de sauter de l'exécution du corps de fonction. Et fournir la valeur de retour de cet appel. L'instruction Throw déclenche ou lance une exception, qui est utilisée avec l'instruction Try / Catch / Enfin, qui spécifie la logique de code de gestion d'exception. Il s'agit d'une déclaration de saut complexe. Lorsqu'une exception est lancée, le programme passe à l'étoile d'exception fermée la plus proche. Ce programme d'exception peut être dans la même fonction ou dans la pile d'appels à un niveau supérieur.

Ensuite, décrivez chaque déclaration de saut

je. Déclaration d'étiquette

Une déclaration peut être étiquetée et l'étiquette est composée de l'identifiant et du côlon avant la déclaration:

Identifiant: déclaration

En définissant une balise pour une instruction, vous pouvez vous référer à cette instruction par son nom de balise n'importe où dans le programme. Vous pouvez définir des étiquettes pour plusieurs instructions, bien qu'elle ne soit plus utile que lors de la définition d'étiquettes pour les blocs d'instructions, tels que des instructions de boucle ou des instructions de jugement conditionnel. En définissant un nom de balise pour la boucle, vous pouvez utiliser Break et continuer à l'intérieur du corps de la boucle pour quitter la boucle ou défier directement au début de la boucle suivante. break and continue are the only statements in JavaScript that can use statement tags (this chapter will be discussed next). The following example, where the while loop defines a tag, and the continue statement uses this tag:

La copie de code est la suivante:

mainloop: while (token != null) {

//忽略这里代码...

continue mainloop; //跳转到下一次循环

//忽略这里的代码...

}

这里做标签的indentifier必须是一个合法的javascript标识符，而不能是一个保留字。标签的命名空间和变量或函数的命名空间是不同的，因此可以使用同一个标识符作为语句标签和作为变量名或函数名。语句标签只在它所起作用的语句（当然可以在它的子句）内是有定义的。一个语句标签不能和它内部的语句标签重名，但在两个代码不相互嵌套的情况下是可以出现同名语句标签的。带有标签的语句还可以带有标签，也就是说，任何语句可以有很多个标签。

ii.break

The purpose of using break statements alone is to immediately exit the most memory loop or switch statement. Sa syntaxe est la suivante:

casser;

由于它能够使循环和switch语句退出，因此这种形式的break只能出现在这类语句中才是合法的。

我们在switch语句的例子中已经见到果break语句。在循环中，无论出于什么原因，只要不想继续执行整个循环，就可以用break提前退出。当循环终止条件非常复杂时，要函数体内使用break语句实现这样些条件判断的做法要比直接在循环表达式中写出这个复杂的终止条件做法简单的多。

下面的例子中循环遍历整个数组元素来查找某个特定的值，当整个数组遍历完成后正常退出循环，如果找到了需要查找的数组元素，则使用break语句退出循环：

La copie de code est la suivante:

for (var i = 0; i < a.length; i++) {

if (a[i] == target) break;

}

javascript中同样允许break关键字后跟随一个语句标签，（只有标识符，没有冒号）

Break Labelname;

当break和标签一块使用时，程序将跳转到这个标签所识别的语句块的结束，或者直接终止这个闭合语句块的执行。当没有任何闭合语句块指定break所用的标签，这时会产生一个语法错误。当使用这种形式的break语句时，带标签的语句不应该是循环或者switch语句，因为break语句可以“跳出”任何闭合的语句块。这里的语句可以是由花括号组起来的一组语句，使用同一个标签来识别一组语句。

break关键字和labelname之间不能换行。因为javascript可以给语句自动补全省略掉的分号，如果break关键字和标签之间有换行，javascript解释器会认为你在使用break不带标签的最简形式，因此会在break后补充分号.

当你希望通过break来跳出非就近的循环体或者switch语句时，就会用到带标签的break语句。下面是示例代码：

La copie de code est la suivante:

var matrix = getData(); //从某处获得一个二维数组

//将矩阵中所有元素进行求和

var sum = 0,

success = false;

//从签名处开始，以便在报错时推出程序。

compure_sum: if (matrix) {

for (var x = 0; x < matrix.length; x++) {

var row = matrix[x];

if (!row) break compure_sum;

for (var y = 0; y < row.length; y++) {

var cell = row[y];

if (isNaN(cell)) break compure_sum;

sum += cell;

}

}

success = true;

}

//break语句跳转至此

//如果success =false条件到达这里，说明我们给出的矩阵中有错误

//否则对矩阵中所有的元素进行求和

最后，需要注意的是，不管break语句带不带标签，它的控制权都无法越过函数的边界。比如：对于一条带标签的函数定义语句来说，不能通过函数内部通过这个标签来跳转到函数外部.

iii.continue语句

continue语句和break语句非常类似，但它不退出循环，而是转而执行下一次循环。continue语句的语法和break的语句语法一样简单

continuer;

continue语句会也会带有标签

continue lebname;

不管continue语句带不带标签，它只能在循环体使用，在其它地方使用将会报语法错误。

当执行到continue语句的时候，当前的循环逻辑就终止了，随即执行下一次循环，在不同类型的循环中，continue的行为也有区别

1.在while循环中，在循环开始处指定expression会重复检测，如果检测结果为true，循环体会从头执行。

2.在do/while循环中，程序的执行至今跳转到循环的结尾处，这时会重新判断循环条件，之后才会继续下一次循环。

3.在for循环中，首先会计算自增表达式，然后再检测test表达式，用以判断是否执行循环体。

4.在for/in循环中，循环开始遍历下一个属性名，这个属性名赋给了指定的变量。

需要注意continue语句在while和for循环中的区别，while循环直接进入下一轮的循环条件判断，但for循环首先计算器increment表达式，然后判断循环条件。之前的章节讨论了和while循环“等价”的for循环行为。但由于continue在这两种循环中行为表现不同，因此使用while循环不可能完美的模拟等价的for循环。

下面这段代码展示了不带标签的continue语句，产生一个错误的时候跳过当前循环的后续逻辑

La copie de code est la suivante:

for (i = 0; i < data.length; i++) {

if (!data[i]) continue; //不能处理undefined数据

total += data[i];

}

和break语句类似，带标签的continue语句可以用在嵌套的循环中，用以跳出层次嵌套的循环体逻辑。同样和break语句类似，在continue语句和labname之间不能有换行。

iiii.return

回想一下，函数调用的一种表达式，而且所有的表达式都有值。函数中的return语句即是指函数调用后的返回值。这里是return语句的语法：

return expression;

The return statement can only appear in the function body. If not, it will report a syntax error. When the return statement is executed, the function terminates the execution and returns the value of the expression to the calling program. Par exemple:

La copie de code est la suivante:

function square(x) {return x * x} //一个包含return的语句函数

square(4) //执行为16

如果没有return语句，则函数调用仅依次执行函数体内的每一条语句直到函数结束，最后返回调用程序。这种情况下，调用表达式的结果是undefined。return语句经常作为函数内最后的一条语句出现，但并不是说一定一定要放在函数的最后，即使在执行return语句的时候还有很多代码没有执行到，这时候函数也还返回调用程序。

The return statement can be used alone without having expression, so the function will also want to call the program to return undefined. Par exemple:

La copie de code est la suivante:

//如果参数是null或者undefined则立即返回

if (!o) return;

//其它逻辑

由于javascript可以自动插入分号，因此，return关键字和它后面的表达式之间不能有换行。

iiiii.throw语句

所谓异常（excepion）是当发生了某种异常情况或错误时产生的一个信号。抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，抛出异常，就是用信号通知发生了错误或异常状况。捕获异常是指处理这个信号，即采取必要的手段从异常中汇丰。在javascript中，当产生运行时错误或者程序使用throw语句时就会显式的抛出异常。使用try/catch/finally语句可以捕获异常，下一节会对它作详细介绍。

throw语句的语法如下：

throw expression

expression的值可以是任意类型的。可以抛出一个代表错误码的数组，或者包含可错误消息的字符串。当javascript解释器抛出异常的时候，通常采用Eeeor类型或其子类型，当然也可以使用它们。一个error对象有一个那么熟悉表示错误类型，一个message属性用来传递构造函数的字符串（参照第三部分的Error类），在下面的例子中，当使用非法参数调用函数时就抛出一个Error对象：

La copie de code est la suivante:

function fa(x) {

//如果输入的参数是非法的，则抛出一个异常

if (x < 0) throw new Error("x不能是负数。");

//否则计算出一个值，正常地返回它

for (var f = 1; x > 1; f *= x, x--) /*empty*/;

return f;

}

当抛出异常时，javascript解释器会立即停止当前正在执行的逻辑，并跳转至就近的异常处理程序。异常处理程序用try/catch/finally语句的catch从句编写的。如果抛出的异常没有一条关联catch从句，解释器会检测更高层的闭合代码块，看它是否关联相关的异常处理程序。以此类推，直到扎到一个异常处理的程序为止。

如果抛出的异常函数没有处理它的try/catch/finally语句，异常将向上传播到调用该函数的代码。这样的话，异常就会沿着javascript方法的词法结构和调用栈向上传播。如果没有找到任何异常处理的程序，javascript将吧异常当成程序错误来处理，并报告给用户。

iiiiii.try/catch/finally语句

try/catch/finally语句是javascript的异常处理机制。其中try从句定义了需要处理的异常所在代码块。catch语句跟随在try从句之后，当try块从某处发送了异常时，调用了catch内的代码逻辑。catch从句跟随finnlly块，后者防置了清理代码，不管try块中是否产生了异常，finnally块内的逻辑总会执行。尽管catch和finally都是可选的，但try从句只杀二者之一与组成完整的语句。try、catch和finally语句块都需要花括号括起来，这里的花括号是必须的。即使从句中只有一条语句也不能省略花括号。

下面的代码说明了try/catch/finlly的语法和使用目的：

La copie de code est la suivante:

essayer{

//通常来讲，这里的代码会从头执行到尾而不会产生任何问题，

//但有时会抛出一个异常，要么是由throw语句直接抛出异常

//要么通过调用一个方法间接抛出异常

}

catch(e){

//当且仅当try抛出了异常，才会执行这里的代码

//这里可以通过局部变量e来获得对Error对象或者抛出的其它值的引用

//这里的代码可以基于某种原因处理这个异常，也可以忽略这个异常。

//还可以通过throw语句重新抛出异常

}

Enfin{

//不管try语句块是否抛出看异常，这里的逻辑总会执行，终止try的语句块方式有：

//1）正常终止，执行完语句块的最后一条语句

//2）通过break，continue或return语句终止

//3）抛出一个异常，异常被catch从句捕获

//4）抛出一个异常，异常未被捕获，继续向上传播

}

我们注意到，关键字catch后跟随了一对圆括号，圆括号内是一个标识符。这个标识符和函数参很像。当捕获一个异常时，把这个异常相关的值（比如Error对象）赋值给这个参数。和普通的变量不同，这条catch子句中的标识符具有块级作用域，它只在catch语句块内有定义。

这里有一个关于try/catch语句更实际的例子，这里使用了前面章节中提到factorial()方法，并使用客户端javascript方法prompt()和alert()来输入和输出

La copie de code est la suivante:

essayer {

//要求用户输入一个数字

var n = Number(prompt("请输入一个正整数", ""));

//假设输入是合法的，计算这个阶乘

var f = factorial(n);

//显示结果

alert(n + "!=" + f);

} catch (ex) {

//如果输入不合法，将执行这里的逻辑

document.write(ex); //告诉用户发送了什么。

}

这里的try/catch语句并不包含finally从句。尽管finally不像catch那样经常使用，但有时候它还是非常有用。然而，我们需要更详尽的解释它的行为。不管try语句块中的代码执行完成了多少，只要try语句中有一部分代码执行了，finally从句就会执行。它通常在try从句的代码后用于清理工作。

关注下面这个例子

La copie de code est la suivante:

essayer {

print("Outer try running..");

essayer {

print("Nested try running...");

throw "an error";

} catch (e) {

print("Nested catch caught " + e);

throw e + " re-thrown";

} enfin {

print("Nested finally is running...");

}

} catch (e) {

print("Outer catch caught " + e);

} enfin {

print("Outer finally running");

}

// Windows Script Host 作出该修改从而得出WScript.Echo(s)

function print(s) {

document.write(s);

}

Sortir:

La copie de code est la suivante:

Outer try running..

Nested try running...

Nested catch caught an error

Nested finally is running...

Outer catch caught an error re-thrown

Outer finally running

7.其它语句类型。

本节讨论剩余的三种javascript语句：width，debugger和use strict

i.with语句

3.10讨论了作用域链（scope chain），一个可以按序检索的对象列表，通过它可以进行变量名的解析。width语句可以用来临时扩展作用域链：它具体有如下语法：

with (object)

déclaration

这条语句将object添加到作用域链头部，然后执行statement，最后把作用域链恢复到原始状态。

在严格模式下（5.7.iii）是禁止使用width的，在非严格模式下也是不推荐使用width语句的，尽可能的避免使用width语句。那些使用width语句的javascript非常难优化，而且比没有使用width的语句，它运行速度更慢。

在对象嵌套层次很深的时候，常会使用with语句来简化代码的编写。例如客户端javascript中，可能使用下面的这种表达式来访问表单的一个html元素

document.forms[0].address.value

如果这段代码多次出现，则可以使用with将form对象添加至作用域链的顶层。

La copie de code est la suivante:

with(document.forms[0]){

//直接访问表单元素

name.value="";

address.value="";

email.value ="";

}

这种方法简化了大量的输入，不用再为每个变量添加document.forms[0]前缀。这个临时对象挂载在作用域链上，当javascript需要解析诸如address标识符时，就会在这个对象中查找。当然，不使用with的语句代码可以写成这样。

La copie de code est la suivante:

var f = document.forms[0];

f.name.value = "";

f.adress.value = "";

f.email.value = "";

不要忘记，只有在查找标识符的时候才能用到作用域链，创建新的变量时候不使用它，看一下下面的代码：

La copie de code est la suivante:

with(o) x = 1;

如果对象o有一个属性x，那么这行代码给这个属性赋值1。如果o没有定义属性x，这段代码和不使用with的代码x=1是一模一样的。它给一个局部变量或者全局变量x赋值，或者创建全局对象的一个新属性。with语句提供了一种读取o属性的快捷方法，但并不会创建o的属性。

ii.debugger语句

debugger语句通常什么也不做。然而，在调试程序可用并运行的时候，javascript解释器将会（非必须）以调试模式运行。实际上，这条语句产生一个断点（breakpoint），javascript代码执行会停止在断点的位置，这时可用使用调速器输出变量的值，检查调用栈等。

例如加上调用函数f()的时候使用了未定义的参数，因此f()抛出一个异常，但无法定位到到底哪里出了异常。为了有助于调试这个问题，需要修改f()：

La copie de code est la suivante:

function f(o){

if (o === undefined) debugger; //这段代码用来临时调试

console.log(1) //函数的其它部分

}

f();

这时候，当调用f()没有传入参数，程序将停止执行，这时候通过调用调速器检测调用栈并找出错误的原因。

在ECMAScirpt5中，debugger语句已经正式加入到专门语言里，但在很长的一段时间里，主浏览器的厂商已经将其实现了。注意，可用的调速器是远远不够的，debugger语句不会启动调试器。但如果调试器已经在运行，这条语句才会正在产生断点。例如，使用Firefox插件firebug，首先启动firebug，这样debugger语句才能工作。

iii.“use strict”

“use strict”是ECMASCript5引入的一条指令。指令不是语句（但非常接近于语句），“use strict”和普通语句之前有两个重要区别：

1.它不包含任何语言的关键字，指令仅仅是一个包含一个特殊字符串直接量的表达式（可以是使用单引号也可以是双引号）。

2.它只能出现在脚本代码的开始或者函数体的开始、任何实体语句之前。但它不必一定出现在脚本的首行或者函数体内的首行。因为“use strict”指令之前之后或之前都可能有其它字符串直接量的表达式语句，并且javascript的具体实现可能将它们解析为解释器自有的指令。在脚本或者函数体内第一条常规语句之后，字符串直接量表达式语句只当做普通的表达式语句对待，它们不做指令解析，它们也没有任何副作用。

使用“use strict”指令的目的是说明（脚本或函数中）后续代码解析为严格代码(strict code)。如果顶层（不在任何函数内）代码使用了“use strict”指令，那么它们就是严格代码。如果函数体定义处的代码是严格代码或者函数体使用了“use strict”指令，那么函数体的代码也是严格代码。如果eval()调用所处的代码是严格代码或者eval()要执行的字符串使用了“scrict code”指令，则eval()内的代码是严格代码。

严格代码以严格模式执行。ECMAScript5中的严格模式是该语言的一个受限的子集。它修正了语言的重要缺陷，并提供健壮的差错功能和增强安全机制。严格模式和非严格模式区别如下（前三条尤其重要）

•严格模式中禁止使用with语句

•严格模式中，所有的变量要先声明，如果给一个未声明的变量、函数、函数参数、catch从句参数或全局的对象的属性赋值。就会抛出一个引用错误异常（在非严格模式中，这种隐式声明全局变量的方法是给全局变量新添加一个新属性）

•严格模式中，调用的函数（不是方法）中的一个this值是undefined。（在非严格模式中，调用的函数中的this值总是全局变量）。可以利用这种特性来判断javascript实现是否支持严格模式。

La copie de code est la suivante:

var hasStrictMode = (function() {

"use strict";

return this === undefined

}());

•同样，在严格模式中，当通过call()和apply()来调用函数时，其中的this值就是通过call()或apply()传第一个参数（在非严格模式中，null和undefined值被全局对象转换为对象的非对象值锁代替）

•在严格模式中，给只读属性赋值和给不可扩展的对象创建成员都将抛出一个类型错误异常（在非严格模式中，这些操作只是简单的操作失败，不会报错）。

•在严格模式中，传入eval()代码不能再调用辰星所在的上下文中声明变量或定义函数，在非严格模式中是可以这样做的。相反，变量和函数的定义是在eval()创建的作用域中，这个作用域在eval()返回时就弃用了。

•在严格模式中，函数里的arguments对象拥有传入函数值的静态副本。在非严格模式中，agreements对象具有“魔术般”的行为，arguments里的数组元素和函数都指向同一个值的引用。

•在严格模式中，当delete运算符后面跟随非法的标识符（比如变量、函数、函数参数时）将会抛出一个语法错误，（在非严格模式下，这种delete什么也没做，并返回false）

•在严格模式中，在一对象直接量中定义两个或多个同名属性将产生一个语法错误（非严格模式下不会报错）

•在严格模式下，不允许八进制整数直接量。（以0为前缀，而不是0x为前缀）在非严格模式中是允许直接八进制直接量的

•在严格模式下，标识符eval和arguments当做关键字，他们的值是不能更改的。不能给这些标识符赋值，也不能把它们声望为变量，用做函数名，用做函数参数或用做catch块的标识符。

•在严格模式中限制了对调用栈的检测能力，在严格的模式的函数中，arguments，caller和arguments.callee都会抛出一个类型错误异常。严格模式的函数同样具有caller和arguments属性，当访问这两个属性时抛出类型错误异常。

8.javascript语句小结：

javascript语句语法：