Javascript base lecture phrases_javascript compétences

En JavaScript, les expressions sont des phrases et les déclarations sont des phrases ou des commandes entières. Tout comme les déclarations anglaises se terminent par un point, JavaScript se termine par un point-virgule.

Une expression est évaluée à une valeur, mais une instruction provoque quelque chose.

Une façon de "faire bouger les choses" est d'évaluer une expression avec des effets secondaires. Les expressions ayant des effets secondaires, telles que les affectations et les appels de fonction, peuvent être traitées comme des instructions distinctes. Cette utilisation d'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'instructions exécutables. Par défaut, l'interpréteur JavaScript les exécute dans l'ordre. Une autre façon de "faire bouger quelque chose" est de modifier l'ordre d'exécution par défaut des instructions :

1. Instruction conditionnelle : l'interpréteur JavaScript peut juger en fonction de la valeur d'une expression s'il convient d'exécuter ou d'ignorer ces instructions, telles que les instructions if et switch.

2. Instruction de boucle : instruction qui peut être exécutée à plusieurs reprises, comme les instructions while et for

3. Instruction Jump : permet à l'interprète de passer à d'autres parties du programme pour continuer l'exécution, telles que les instructions break, return et throw

L'article suivant présentera diverses instructions et leur syntaxe en JavaScript. Le chapitre se termine par un résumé de ces déclarations. Un programme javascript n'est rien de plus qu'un ensemble d'instructions séparées par séparation, donc une fois que vous maîtrisez les instructions javascript, vous pouvez écrire des programmes javascript.

1. Déclaration d'expression

L'instruction d'affectation est une instruction d'expression relativement importante. Sa fonction est de changer la valeur d'une variable, tout comme l'exécution d'une instruction d'affectation : par exemple

Copier le code Le code est le suivant :

              greet = "bonjour" nom;
             je *= 3;

L'opérateur d'incrémentation ( ) et l'opérateur de décrémentation (--) sont liés aux instructions d'affectation. Leur but est de modifier la valeur d'une variable, tout comme l'exécution d'une instruction d'affectation.

Copier le code Le code est le suivant :

compteur ; 

Le rôle important de l'opérateur

delete est de supprimer les attributs d'un objet (ou les éléments d'un tableau), il est donc généralement utilisé comme une instruction plutôt que comme partie d'une expression complexe.

Copier le code Le code est le suivant :

supprimer o.x ;

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

Copier le code Le code est le suivant :

alerte(salut);
              window.close();

Bien que ces fonctions côté client soient des expressions, elles ont un certain impact sur les navigateurs Web. Nous pensons donc aussi aux déclarations : cela n'a pas de sens d'appeler une fonction qui n'a aucun effet secondaire à moins qu'elle ne fasse partie d'une expression complexe ou d'une instruction d'affectation, par exemple. Il est impossible de jeter une valeur de cosinus avec désinvolture

Math.cos(x);

En revanche, pour obtenir la valeur du cosinus, il faut l'attribuer à une variable afin que la valeur puisse être utilisée dans le futur :

var cx = Math.cos(x);

Rappelez encore une fois à tous que chaque ligne de code se termine par un point-virgule.

2. Déclarations composées et déclarations vides

Vous pouvez utiliser l'opérateur virgule pour joindre plusieurs expressions afin de former une seule expression. De même, JavaScript peut également combiner plusieurs instructions pour former une instruction composée. Placez simplement plusieurs instructions entre accolades. Par conséquent, les lignes de code suivantes peuvent être traitées comme une seule instruction et utilisées n'importe où dans JavaScript où une instruction est souhaitée.

Copier le code Le code est le suivant :

{
                    x = Math.PI;
                      cx = Math.cos(x);
console.log("cos(π)=" cx);
            }

Il y a quelques points à noter à propos des blocs d'instructions : Premièrement, les blocs d'instructions ne nécessitent pas de points-virgules. Les instructions d'élément dans un bloc doivent se terminer par un point-virgule, ce qui n'est pas le cas des blocs d'instructions.

Deuxièmement, les lignes du bloc d'instructions sont en retrait. Cela 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 un bloc d'instructions ne sont pas privées du bloc d'instructions. (Se référer à la première section du chapitre 3, section 10)

La pratique consistant à fusionner de nombreuses instructions dans un grand bloc d'instructions est très courante dans la programmation JavaScript. Les expressions similaires contiennent souvent des sous-expressions, et de nombreux JavaScript contiennent d'autres sous-instructions. Formellement, JavaScript permet généralement à un bloc d'instructions de contenir une sous-instruction. Par exemple : le corps d’une boucle while ne peut contenir qu’une seule instruction. À l'aide de blocs d'instructions, vous pouvez placer n'importe quel nombre d'instructions dans ce bloc, et ce bloc d'instructions peut être utilisé comme une seule instruction.

En JavaScript, lorsque vous souhaitez que plusieurs instructions soient utilisées comme une seule instruction, utilisez plutôt une instruction correspondante. Une instruction vide est tout le contraire, autorisant 0 instruction. Une instruction vide ressemble à ceci :

;//Point-virgule

L'interpréteur JavaScript n'effectue évidemment aucune action lors de l'exécution d'une instruction 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 la boucle for suivante

Copier le code Le code est le suivant :

//Initialiser un tableau a
pour (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 la boucle contienne au moins une instruction, c'est pourquoi un seul point-virgule est utilisé ici pour représenter une instruction vide.

Notez que le point-virgule dans la parenthèse droite d'une boucle for, d'une boucle while ou d'une instruction if est très discret, ce qui est susceptible de provoquer des bugs fatals, et ces bugs sont difficiles à localiser. Par exemple, le résultat de l'exécution du code suivant est susceptible d'être l'effet que l'auteur n'a pas prévu :

Copier le code Le code est le suivant :

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 dans un but particulier, il est préférable d'ajouter des commentaires dans le code pour indiquer plus clairement que cette instruction vide est utile

Copier le code Le code est le suivant :

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

3. Déclaration de déclaration

Var et function sont des instructions de déclaration, qui déclarent ou définissent des variables ou des fonctions. Ces instructions définissent et attribuent des valeurs aux identifiants (noms de variables et de fonctions) qui peuvent être utilisés n'importe où dans le programme. L'instruction de déclaration en elle-même ne fait rien, 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 prochaines sections décriront l'instruction var et l'instruction de fonction, mais elles ne couvrent pas tout le contenu 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 nom_1[ = valeur_1][, ..., nom_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 :

Copier le code Le code est le suivant :

              var i ; //Une variable simple
                var j = 0 //Une variable avec une valeur initiale
               var p, q //Deux variables
               var greet = "hello" name ; // Expression d'initialisation plus complexe
               var x = 2,34,y = Math.cos(0,75),r, theta //De nombreuses variables
               var x = 2,y = x * x; //La deuxième variable utilise la première variable
         var x = 2,
                                                                                                                                                                                                                                                    f = function(x) {return x * x}, //Chaque variable a sa propre ligne
            y = f(x)

Si l'instruction var apparaît dans le corps de la fonction, alors une variable locale est définie et sa portée est cette fonction. Si vous utilisez l'instruction var dans le code de niveau supérieur, elle déclare une variable globale, visible dans tout JavaScript. C'est mentionné au chapitre 3, section 10 : Les variables globales sont des attributs de l'objet global Contrairement aux autres attributs d'objet global, les variables déclarées avec var ne peuvent pas être supprimées via delete.

Si la variable dans l'instruction var ne spécifie pas d'expression d'initialisation, alors la valeur de cette variable est initialement indé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 d'une boucle for ou d'une boucle for/in. (La même chose que la déclaration de variable déclarée avant la boucle, la variable déclarée ici sera également "avancée"), par exemple :

Copier le code Le code est le suivant :

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 cela n'a pas d'importance si vous déclarez la même variable plusieurs fois.

ii.fonction

Le mot-clé function est utilisé pour déclarer des fonctions. Nous avons déjà appris les expressions de fonctions (4.3). Les définitions de fonctions peuvent être écrites sous forme d'instructions. Par exemple : les deux méthodes d'écriture de définition dans l'exemple de code ci-dessous :

Copier le code Le code est le suivant :

                var f = function f(x) {return x 1;} //Attribuer l'expression à une variable
               function f(x){return x 1;} //Instruction contenant le nom de la variable

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

Copier le code Le code est le suivant :

function funcname([arg1[, arg2[..., argn]]]) {
déclarations
            }

funcname est l'identifiant du nom de la fonction à déclarer. Après le nom de la fonction se trouve la liste des paramètres, séparés par des virgules. Lorsqu'une fonction est appelée, ces identifiants font référence aux paramètres réels transmis à la fonction.

Le corps de la fonction est composé d'instructions JavaScript. Il n'y a pas de limite au nombre d'instructions et elles sont placées entre accolades. Lorsqu'une fonction est définie, les instructions dans le corps de la fonction ne sont pas exécutées, mais sont associées au nouvel objet fonction à exécuter lorsque la fonction est appelée. Notez que les accolades dans l'instruction de fonction sont obligatoires, ce qui est différent des blocs d'instructions utilisés par les boucles while et autres verrous d'instruction. Même si le corps de la fonction n'a qu'une seule instruction, des accolades sont toujours nécessaires pour la délimiter.

Copier le code Le code est le suivant :

fonction hyteus(x, y) {
                      return Math.sqrt(x * x y * y);
            }
hyteus(1, 2) //=>2.23606797749979
              function facial(n) { //Une fonction récursive
Si (n <= 1) renvoie 1;
Retour n * facial(n - 1);
            }
facial(11) //=>39916800

La déclaration d'une fonction apparaît généralement en haut du code JavaScript et peut également être imbriquée dans le corps d'autres fonctions. Mais lorsqu'elles sont imbriquées, les déclarations de fonction ne peuvent apparaître qu'en haut de la fonction imbriquée. C'est-à-dire : les définitions de fonctions ne peuvent pas apparaître dans if, while ou d'autres instructions.

Comme l'instruction var, les variables créées par l'instruction de déclaration de fonction ne peuvent pas être supprimées. Mais ces variables ne sont pas en lecture seule et les valeurs des variables peuvent être écrasées.

4. Déclaration conditionnelle

Les instructions conditionnelles sont utilisées pour exécuter ou ignorer certaines instructions en jugeant si la valeur de l'expression spécifiée l'est. Ces déclarations sont des « points de décision » du code, parfois appelés « branches ». Si l'interpréteur javascript est exécuté selon le "chemin" du code. Les instructions conditionnelles sont à la croisée des chemins. Le programme atteint ce point et doit choisir un chemin pour continuer son exécution.

Déclaration i.if

L'instruction

if est une instruction de contrôle de base. Pour être précis, elle permet au programme de s'exécuter de manière conditionnelle. Cette instruction a deux formes : la première est

.

Copier le code Le code est le suivant :

Si (expression)
déclaration

Sous cette forme, la valeur de l'expression est jugée. Si elle est vraie, l'instruction est exécutée. Si elle est fausse, l'instruction n'est pas exécutée.

Copier le code Le code est le suivant :

If (username == null) //Si le nom d'utilisateur est nul ou non défini
                    username = "jack wong" // Définissez-le
;

Il convient de noter que les parenthèses entourant l'expression dans l'instruction if sont nécessaires.

La syntaxe Javascript stipule que le mot clé if et l'expression entre parenthèses doivent être suivis d'une instruction. Cependant, vous pouvez utiliser des blocs d'instructions pour combiner plusieurs instructions en une seule. Par conséquent, l'instruction if ressemble à ceci :

Copier le code Le code est le suivant :

                 si (!adresse) {
                adresse = "";
                  message = "veuillez adresse postale"
            }

La deuxième forme de l'instruction if introduit la clause else Lorsque la valeur de l'expression est fausse, la logique else est exécutée

Copier le code Le code est le suivant :

Si (expression)
                déclaration 1
          autre
                déclaration 2

Par exemple, le code suivant

Copier le code Le code est le suivant :

                  si (n == 1)
console.log("1 nouveau message");
          autre
console.log("vous avez" n "nouveau message");

Lors de l'imbrication d'instructions if dans des instructions if/else, il faut veiller à ce que l'instruction else corresponde à l'instruction if correcte. Considérez le code suivant :

Copier le code Le code est le suivant :

              i = j = 1;
               k = 2;
                 si (i == j)
Si (j == k)
console.log("i equs k");
          autre
                  console.log("i est égal à j"); //Erreur ! !

Dans cet exemple, l'instruction if interne forme les clauses requises par l'instruction if externe. Cependant, la relation de correspondance entre if et else n'est pas claire (seule l'indentation donne un indice) et dans ce cas, l'indentation donne un indice erroné, car c'est ainsi que l'interpréteur JavaScript le comprend.

Copier le code Le code est le suivant :

Si (i == j) {
Si (j == k)
console.log("i equs k");
Sinon console.log("je suis égal à j");
            }

Comme la plupart des langages de programmation, les règles de correspondance if et else en JavaScript sont que else correspond toujours à l'instruction if la plus proche. Afin de rendre l'exemple plus lisible, plus facile à comprendre et plus facile à maintenir et à déboguer, des accolades doit être utilisé

Copier le code Le code est le suivant :

Si (i == j) {

Si (j == k) {
console.log("i equs k");
                                                                                                                                                                                                                                                                                                        . console.log("je suis égal à j");
                }
            }



De nombreux programmeurs auront l'habitude de placer le corps des instructions if et else entre accolades (tout comme dans les instructions correspondantes comme les boucles while). Même s'il n'y a qu'une seule instruction par branche, cela peut éviter le problème pour le moment. Problème d'ambiguïté du programme.

ii.sinon si

L'instruction if/else sélectionne l'une des deux branches en jugeant le résultat de l'évaluation d'une expression. Que devons-nous faire lorsqu’il y a de nombreuses branches dans le code ? Une solution consiste à utiliser une instruction else if. else if n'est pas une véritable instruction javascript, c'est juste une façon d'écrire plusieurs instructions if/else connectées entre elles.

Copier le code Le code est le suivant :

                  si (n == 1) {
//Exécuter le bloc de code 1
               } sinon si (n == 2) {
//Exécuter le bloc de code 2
                } sinon si (n == 3) {
//Exécuter le bloc de code 3
               } autre {
//Les conditions précédentes sont toutes fausses, puis exécutez le bloc de code 4
            }

Il n'y a rien de spécial dans ce code. Il se compose de plusieurs instructions if, et la clause else de chaque instruction if contient une autre instruction if. Un code syntaxiquement équivalent peut être complété en utilisant une forme imbriquée d'instructions if, mais par rapport à cela, la manière d'écrire else if est évidemment plus claire et préférable.

iii.switch

L'instruction if crée une branche pendant l'exécution du programme, et sinon, if peut être utilisée pour traiter plusieurs branches. Cependant, lorsque toutes les branches dépendent de la valeur de la même expression, sinon ce n'est pas la meilleure solution. Dans ce cas, il serait inutile d’évaluer à plusieurs reprises des expressions dans plusieurs instructions if.

L'instruction switch est adaptée pour gérer cette situation. Le mot-clé switch est suivi d'une expression entre parenthèses. Ceci est suivi d’un bloc de code entouré d’accolades.

Copier le code Le code est le suivant :

changer (expression) {
déclarations
            }

Cependant, la syntaxe complète de l'instruction switch est plus compliquée que cela. Après la casse se trouve une expression et les deux-points sont très similaires à une balise, sauf que la balise n'a pas de nom.

Il est uniquement associé à l'expression qui le suit. Lorsque cette instruction switch est exécutée, elle calcule d'abord la valeur de l'expression, puis vérifie si l'expression dans la clause case est la même que la valeur de l'expression. (La similarité ici est comparée selon l'opérateur "==="), si la casse correspond, il exécutera le code correspondant. Si aucun cas correspondant n'est trouvé, il exécutera le bloc de code dans la balise "default:". Sans la balise « default : », switch ignorera tous les blocs de code.

L'instruction switch est très facile à confondre. Elle sera plus claire avec un exemple. L'instruction switch ci-dessous est équivalente à l'instruction if/else de tout à l'heure

Copier le code Le code est le suivant :

commutateur (n) {
                     cas 1 : //Si n ===1, commencez à partir d'ici
//Exécuter le bloc de code 1
pause;
                cas 2 :
//Exécuter le bloc de code 2
pause;
                cas 3 :
//Exécuter le bloc de code 3
pause;
                                                                                                                                                                                                                                                                              par défaut :
//Exécuter le bloc de code 4
pause;
            }

Il convient de noter que le mot-clé break est utilisé à la fin de chaque instruction case. Nous présenterons l'instruction break plus tard. L'instruction break peut amener l'interpréteur à sortir de l'instruction switch ou de l'instruction loop. Dans switch, case spécifie uniquement le point de départ du code à exécuter, mais pas le point final. S'il n'y a pas d'instruction break, l'instruction switch commence à s'exécuter à partir du code au niveau de l'étiquette de cas correspondante de la valeur de l'expression et exécute les instructions suivantes en séquence jusqu'à la fin de l'intégralité du bloc de code switch. Bien sûr, si vous utilisez une instruction switch dans une fonction, vous pouvez utiliser return pour remplacer break. Return et break sont tous deux utilisés pour terminer l'instruction switch et empêcheront également le bloc d'instruction case suivant de continuer à s'exécuter après l'exécution d'une instruction case. exécuté.

L'instruction suivante est proche de la pratique, elle convertit la valeur en chaîne selon son type.

Copier le code Le code est le suivant :

              fonction convert(x) {
commutateur (type de x) {
case 'number' : //Convertir le nombre en hexadécimal
Retourner x.toString(16);
cas 'chaîne' :
                          return '"' x '"' //Renvoie deux chaînes avec des guillemets doubles.
par défaut : //Utilisez des méthodes ordinaires pour convertir d'autres types
                                              return String(x);                 }
            }
console.log(convert(100255114)) //=>5f9c58a

Notez que dans les deux exemples ci-dessus, le mot-clé case est suivi de nombres et de chaînes littérales. En pratique, il s'agit de l'utilisation la plus courante de switch, mais la norme ECMAScript permet à chaque mot-clé d'être suivi de n'importe quelle expression Mode.

L'instruction switch calcule d'abord l'expression après le mot-clé switch, puis calcule l'expression après chaque cas dans l'ordre de haut en bas jusqu'à ce que la valeur de l'expression case soit égale à la valeur de l'expression switch. Étant donné que l'opération de correspondance pour chaque cas est en fait une comparaison d'opérateur d'identité "===" au lieu de "==", aucune conversion de type n'est effectuée pour la mise en correspondance des expressions et des cas.

Chaque fois qu'une instruction switch est exécutée, toutes les expressions case ne peuvent pas être exécutées. Par conséquent, les expressions case avec des effets secondaires, telles que les expressions d'appel de fonction et les expressions d'affectation, doivent être évitées. L'approche la plus sûre consiste à utiliser des expressions constantes dans les expressions case.

Comme mentionné précédemment, si l'expression switch ne correspond à aucune expression case, le bloc d'instruction marqué par "default:" sera exécuté. S'il n'y a pas d'étiquette "default:", l'intégralité de l'instruction switch sera ignorée. Dans l'exemple précédent, la balise "default:" apparaît à la fin du commutateur, après toutes les balises case. Bien sûr, c'est la manière d'écrire la plus raisonnable et la plus couramment utilisée. En fait, la balise "default:" peut être placée n'importe où dans l'instruction switch.

5.

Afin de comprendre les instructions conditionnelles, vous pouvez considérer le code en JavaScript comme des chemins de branchement. Une instruction de bouclage est une boucle dans le chemin du programme qui permet d’exécuter une partie du code de manière répétée. Il existe quatre types d'instructions de boucle en JavaScript : while, do/while, for, for/in. Les sections suivantes les expliqueront toutes en même temps. La boucle la plus couramment utilisée est la traversée des éléments du tableau. (7.6 discutera en détail de cette boucle et de la méthode de boucle spéciale définie à l'aide de la classe array.)

je.pendant

L'instruction if est une instruction de contrôle de base, utilisée pour sélectionner l'instruction de branche du programme d'exécution. Comme si, l'instruction while est également une instruction de boucle de base. Sa syntaxe est la suivante :

.

Copier le code Le code est le suivant :

          while (expression)
déclaration

Avant d'exécuter l'instruction while, l'interpréteur JavaScript calcule d'abord la valeur de l'expression. Si sa valeur est fausse, le programme ignorera l'instruction logique dans le corps de la boucle et exécutera l'instruction suivante dans le programme. Si sa valeur est vraie, la logique de l'instruction dans le corps de la boucle est exécutée, puis la valeur de l'expression est calculée. La boucle continuera jusqu'à ce que la valeur de l'expression soit fausse. En d’autres termes, lorsque l’expression est vraie, l’instruction est exécutée en boucle. Notez que l’utilisation de while(true) créera une boucle infinie.

De manière générale, nous ne voulons pas que javascript effectue la même opération encore et encore. Dans presque chaque boucle, une ou plusieurs variables sont itérées dans la boucle. C'est précisément parce que ces variables sont modifiées que les opérations de l'instruction exécutées à chaque fois dans la boucle sont également différentes. De plus, si les variables modifiées sont utilisées dans l'expression, la valeur de l'expression dans chaque boucle sera également différente. C'est très important. L'expression responsable de la valeur initiale vraie sera toujours vraie et la boucle ne se terminera jamais. L'exemple suivant montre la boucle while produisant les valeurs 0 à 9.

Copier le code Le code est le suivant :

var compte = 0;
          while (compte < 10) {
console.log(count);
Compte ;
>

On constate que dans cet exemple, la valeur initiale de la variable count est 0. Pendant la boucle, sa valeur augmente de 1 à chaque fois que la boucle est exécutée dix fois. La valeur de l'expression est programmée sur false, puis le while se terminera et l'interpréteur JavaScript exécutera l'instruction suivante du programme. La plupart des boucles ont une variable compteur comme count. Bien que les noms de variables tels que i j k soient couramment utilisés pour les compteurs, si vous souhaitez rendre le code plus lisible, vous devez utiliser des noms de syntaxe plus spécifiques.

ii.do/while

La boucle do/while est très similaire à la boucle while, sauf qu'elle teste l'expression de la boucle à la fin de la boucle au lieu du haut, ce qui signifie que le corps de la boucle est exécuté au moins une fois. La syntaxe de la boucle do/while est la suivante :

Copier le code Le code est le suivant :

faire
déclaration
             while(expression);

La boucle do/while n'est pas aussi couramment utilisée que la boucle while. En effet, en pratique, il est rare de vouloir qu'une boucle s'exécute au moins une fois. Vous trouverez ci-dessous un exemple de boucle do/while

Copier le code Le code est le suivant :

              fonction printArray(a) {
              var len = a.length,
                      i = 0;
Si (len == 0)
console.log("tableau vide");
Sinon <<>                       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 while ordinaires. Tout d'abord, la boucle do nécessite le mot-clé do pour marquer le début de la boucle, et la variable while pour marquer la fin de la boucle et entrer dans le jugement de la condition de la boucle. Deuxièmement, contrairement à la boucle while, la boucle do se termine par un ; point-virgule. Si le corps de la boucle while est entouré d'accolades, la boucle while ne se terminera pas par un point-virgule.

iii.pour

L'instruction for fournit une structure de contrôle d'instruction de boucle plus pratique que while. L'instruction for apporte quelques simplifications aux modèles de boucles couramment utilisés. La plupart des boucles ont des variables de compteur spécifiques. Initialisez cette variable avant le début de la boucle, puis vérifiez sa valeur avant chaque boucle. Enfin, la variable compteur est incrémentée, sinon elle est modifiée après la fin de la boucle 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 la boucle, chacune utilisant une expression pour les représenter. La syntaxe de l'instruction for est la suivante :

Copier le code Le code est le suivant :

pour (initialiser; tester; incrémenter)
déclaration

Les trois expressions d'initialisation, de test et d'incrément sont séparées par des points-virgules. Elles sont responsables des opérations d'initialisation, du jugement des conditions de boucle et de la mise à jour des variables du compteur. Les mettre sur la première ligne de la boucle permet de mieux comprendre ce que fait la boucle for, et vous évite également d'oublier d'initialiser ou d'incrémenter une variable compteur.

Le moyen le plus simple d'expliquer le fonctionnement d'une boucle for est de lister une boucle while équivalente

Copier le code Le code est le suivant :

               initialiser
              while (test) {
déclaration
incrément ;
            }

En d'autres termes, l'expression d'initialisation n'est exécutée qu'une seule fois avant le début de la boucle. L'expression d'initialisation doit avoir un effet secondaire (généralement une instruction d'affectation). JavaScript autorise également les expressions d'initialisation avec les instructions de déclaration de variable var, afin qu'une variable puisse être déclarée et initialisée. L'expression de test sera exécutée avant chaque boucle et le résultat de l'expression sera jugé pour déterminer s'il convient d'exécuter le corps de la boucle. Avant chaque boucle, l'expression de test sera exécutée et son résultat sera jugé pour exécuter le corps de la boucle. Si le résultat du test est vrai, l'instruction dans le corps de la boucle sera exécutée. Enfin, l'expression d'incrémentation est exécutée. Pour être également utile, l'expression d'incrémentation doit également avoir des effets secondaires. D'une manière générale, il s'agit soit d'une expression d'affectation, soit d'une expression composée d'opérateurs " " et " -- ".

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

Copier le code Le code est le suivant :

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

Bien sûr, certaines boucles sont plus complexes et comportent plusieurs variables itérées à la fois. En JavaScript, cette situation doit utiliser l'opérateur virgule, qui combine l'expression d'initialisation et l'expression d'incrémentation en une seule expression à utiliser dans une boucle for.

Copier le code Le code est le suivant :

            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 étaient toutes des nombres. Les chiffres sont bien sûr les plus couramment utilisés, mais ne sont pas obligatoires. Le code suivant utilise une boucle for pour parcourir les résultats des données de la table et renvoyer le dernier objet de la liste chaînée (c'est-à-dire le premier objet qui ne contient pas l'attribut suivant)

Copier le code Le code est le suivant :

              function tail(o) { //Renvoie le dernier objet nœud de la liste chaînée
for (; o.next; o = o.next) /*empty*/ //Exécuter le parcours en fonction du jugement si o.next est une vraie valeur
                      retour o;
            }

Il est à noter que ce code ne contient pas l'expression initialize. Une et une des trois expressions de la boucle for peuvent être ignorées, mais les deux points-virgules sont indispensables. Si l'expression de test est omise, ce sera une boucle infinie. Semblable au type while(ture), une façon d’écrire une boucle infinie est for(;;).

iiii.for/in

L'instruction for/in utilise le mot-clé for, mais il s'agit d'un type de boucle différent de la boucle for normale. La syntaxe de la boucle for/in est la suivante

Copier le code Le code est le suivant :

pour (variable dans l'objet)
déclaration

variable est généralement un nom de variable, ou il peut s'agir d'une expression qui peut produire une lvalue ou une variable déclarée via l'instruction var. En bref, c'est une valeur qui s'applique au côté gauche de l'expression d'affectation. l'objet est une expression, et le résultat de cette expression est un objet. De même, une instruction est une instruction ou un bloc d’instructions qui forme le corps d’une boucle.

Il est très simple de parcourir les éléments d'un tableau à l'aide d'une boucle for

Copier le code Le code est le suivant :

          var a = [1, 3, 5, "44"];
for (var i = 0; i < a.length; i ) //i représente l'index de l'élément du tableau
console.log(a[i]) //Afficher les éléments de chaque tableau

La boucle for/in est utilisée pour parcourir facilement les attributs des membres d'objet

Copier le code Le code est le suivant :

                 for (var p in o) //Attribuer le nom de l'attribut à la variable p
console.log(o[p]); //Afficher la valeur de chaque attribut

Lors de l'exécution de l'instruction for/in, l'interpréteur JavaScript évalue d'abord l'expression de l'objet. Si l'expression est nulle ou non définie, l'interpréteur JavaScript ignorera la boucle et exécutera le code suivant. Si l'expression est égale à une valeur primitive, la valeur primitive est convertie en l'objet waxer correspondant (Section 3.6). Autrement, l’expression elle-même est déjà un objet. JavaScript énumérera les propriétés de l'objet dans l'ordre pour exécuter la boucle. Cependant, avant chaque boucle, JavaScript évalue l'expression de la variable et lui attribue le nom de la propriété (une chaîne).

Il convient de noter que tant que dans une boucle for/in, la valeur de varibale peut être utilisée comme lvalue de l'expression d'affectation, et il peut s'agir de n'importe quelle expression. Cette expression est évaluée à chaque fois dans la boucle, ce qui signifie qu'elle peut être évaluée à une valeur différente à chaque fois dans la boucle. Par exemple, vous pouvez utiliser le code suivant pour copier toutes les propriétés d'un objet dans un tableau :

Copier le code Le code est le suivant :

          var o = {x : 1,y : 2,z : 3};
          var a = [],i = 0;
pour (a[i ] in o) /*vide*/;
document.write(a)//=> x,y,z

Les tableaux Javascript ne sont qu'un type spécial d'objet, donc les boucles for/in peuvent énumérer les indices de données tout comme les propriétés d'un objet. Par exemple, si vous ajoutez ce code après le code ci-dessus, vous pouvez énumérer l'index de données 0,1,2 :

Copier le code Le code est le suivant :

          var o = {x : 1,y : 2,z : 3};
          var a = [],i = 0;
pour (a[i ] in o) /*vide*/;
                   document.write(a)//=>               pour (je dans un)
                 document.write(i) //=>Indice des données d'énumération 0 1 2

En fait, la boucle for/in ne traversera pas toutes les propriétés de l'objet, seules les propriétés "énumérables" seront parcourues (voir 6.7). Parce que les méthodes intégrées définies par le cœur du langage JavaScript ne sont pas « énumérables ». Par exemple, tous les objets ont toString(), mais la boucle for/in n'énumère pas la propriété toString(). En plus des méthodes intégrées, il existe de nombreuses propriétés d'objet intégrées qui ne sont pas dénombrables (non dénombrables). Toutes les propriétés et méthodes définies dans le code sont énumérables (nous en parlerons dans la section 6.7, mais il existe des moyens spéciaux dans ECMAScript5 pour rendre les propriétés non énumérables).

Les objets peuvent hériter des propriétés d'autres objets, et la ligne de propriétés personnalisées héritées (6.2.ii) peut également être énumérée à l'aide de for/in.

Si le corps de la boucle for/in supprime un attribut qui n'a pas encore été énuméré, alors cet attribut ne sera plus énuméré. Si le corps de la boucle définit de nouvelles propriétés de l'objet, ces propriétés ne sont généralement pas énumérées (cependant, certaines implémentations de JavaScript peuvent énumérer les propriétés ajoutées dans le corps de la boucle).

Ordre d'énumération des attributs

La spécification ECMAScript ne précise pas l'ordre dans lequel les boucles for/in énumèrent les propriétés d'un objet. Mais en fait, l'implémentation JavaScript des principaux fabricants de navigateurs énumère les propriétés des objets simples dans l'ordre dans lequel ils sont définis, les propriétés définies en premier étant énumérées en premier. Si vous créez un objet en utilisant la forme d'un littéral d'objet, les propriétés du littéral sont énumérées dans l'ordre dans lequel elles apparaissent. (Certains sites Web et bibliothèques JavaScript s'appuient sur cet ordre d'énumération, et la plupart des fabricants de navigateurs ne modifient pas cet ordre. Dans les cas suivants, l'ordre d'énumération dépend de l'implémentation spécifique (non interactive)
. 1. L'objet hérite de propriétés énumérables
2. L'objet a des propriétés
avec un index de tableau entier 3. Utilisez delete pour supprimer les attributs existants de l'objet
4. Utilisez Object.defineProperty() ou des méthodes similaires pour modifier les propriétés de l'objet

6. Sauter

Le premier type d'instruction en JavaScript est une instruction de saut. D'après la compréhension de l'instruction, cela peut faire passer l'exécution de javascript d'une position à une autre position.

L'instruction break saute à la fin d'une boucle ou d'une autre instruction. L'instruction continue termine l'exécution de cette boucle et démarre l'exécution de la boucle suivante. Les instructions en JavaScript peuvent être nommées ou étiquetées, et break et continue peuvent identifier des boucles cibles ou d'autres étiquettes d'instructions.

L'instruction return permet à l'interpréteur de sortir de l'exécution du corps de la fonction. Et fournissez la valeur de retour de cet appel. L'instruction throw déclenche ou lève une exception. Elle est utilisée avec les instructions try/catch/finally, qui spécifient la logique du code pour gérer les exceptions. Il s'agit d'une instruction de saut complexe. Lorsqu'une exception est levé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 une pile d'appels de niveau supérieur.

Ensuite, décrivez chaque type d'instruction de saut

i. Déclaration de balise

Les déclarations peuvent être étiquetées. L'étiquette se compose d'un identifiant et de deux points avant la déclaration :

identifiant:déclaration

En définissant une étiquette pour une instruction, vous pouvez référencer l'instruction via le nom de l'étiquette n'importe où dans le programme. Les étiquettes peuvent être définies pour plusieurs instructions, bien qu'elles soient plus utiles lors de la définition d'étiquettes pour des blocs d'instructions, tels que des boucles ou des conditions. En définissant un nom d'étiquette pour la boucle, vous pouvez utiliser break et continue à l'intérieur du corps de la boucle pour quitter la boucle ou contester directement le début de la boucle suivante. break et continue sont les seules instructions en JavaScript qui peuvent utiliser des étiquettes d'instruction (discutées ensuite dans ce chapitre). Dans l'exemple suivant, la boucle while définit une étiquette et l'instruction continue utilise cette étiquette :

Copier le code Le code est le suivant :

               boucle principale : while (jeton != null) {
//Ignorez ce code...
Continuer mapoop; // passer à la boucle suivante
//Ignorez le code ici...
            }

L'identifiant utilisé comme balise ici doit être un identifiant JavaScript légal, et non un mot réservé. L'espace de noms d'une étiquette est différent de l'espace de noms d'une variable ou d'une fonction, vous pouvez donc utiliser le même identifiant comme étiquette d'instruction et comme nom de variable ou de fonction. Une étiquette d'instruction est définie uniquement dans l'instruction sur laquelle elle agit (ou dans ses clauses, bien sûr). Une étiquette d'instruction ne peut pas avoir le même nom que son étiquette d'instruction interne, mais des étiquettes d'instruction portant le même nom peuvent apparaître lorsque les deux codes ne sont pas imbriqués l'un dans l'autre. Les instructions étiquetées peuvent également être étiquetées, c'est-à-dire que toute instruction peut avoir plusieurs étiquettes.

ii.break

La fonction de l'utilisation de l'instruction break seule est de quitter immédiatement l'instruction loop ou switch avec le plus de mémoire. Sa syntaxe est la suivante :

pause;

Puisqu'elle peut provoquer la sortie de boucles et d'instructions switch, cette forme de rupture n'est légale que dans de telles instructions.
Nous avons déjà vu l'instruction break dans l'exemple d'instruction switch. Dans une boucle, si vous ne souhaitez pas continuer à exécuter la boucle entière pour une raison quelconque, vous pouvez utiliser break pour quitter plus tôt. Lorsque la condition de fin de boucle est très complexe, il est beaucoup plus simple d'utiliser l'instruction break dans le corps de la fonction pour implémenter de tels jugements conditionnels que d'écrire la condition de fin complexe directement dans l'expression de boucle.

Dans l'exemple suivant, la boucle parcourt tous les éléments du tableau pour trouver une valeur spécifique. Lorsque l'ensemble du parcours du tableau est terminé, la boucle se termine normalement. Si l'élément du tableau à trouver est trouvé, utilisez l'instruction break pour quitter. la boucle :

Copier le code Le code est le suivant :

pour (var i = 0; i < a.length; i ) {
Si (a[i] == cible) break ;
>

JavaScript permet également que le mot-clé break soit suivi d'une étiquette d'instruction (uniquement identifiant, pas de deux-points)

break labelname;

Lorsque break est utilisé avec une étiquette, le programme sautera à la fin du bloc d'instructions identifié par l'étiquette, ou terminera directement l'exécution du bloc d'instructions fermé. Une erreur de syntaxe se produit lorsqu'il n'y a aucun bloc d'instructions englobant spécifiant une étiquette pour break. Lorsque vous utilisez cette forme d'instruction break, l'instruction étiquetée ne doit pas être une instruction de boucle ou de commutation, car l'instruction break peut « sortir » de n'importe quel bloc d'instructions englobant. L'instruction ici peut être un groupe d'instructions regroupées par des accolades, utilisant la même étiquette pour identifier un groupe d'instructions.

Il ne peut pas y avoir de saut de ligne entre le mot-clé break et le nom de l'étiquette. Étant donné que JavaScript peut compléter automatiquement les points-virgules omis pour les instructions, s'il y a une nouvelle ligne entre le mot-clé break et l'étiquette, l'interpréteur JavaScript pensera que vous utilisez la forme la plus simple de break sans étiquettes, il ajoutera donc un point-virgule après break .
Lorsque vous souhaitez sortir d'une boucle ou d'une instruction switch non proche, vous utiliserez une instruction break étiquetée. Voici l'exemple de code :

Copier le code Le code est le suivant :

          var matrice = getData(); //Obtenir un tableau bidimensionnel quelque part
//Somme tous les éléments de la matrice
      var somme = 0,
              succès = faux ;
​​​​ //Partir de la signature pour lancer le programme lorsqu'une erreur est signalée.
Compure_sum : if (matrice) {
pour (var x = 0; x < matrice.longueur; x ) {
                  var rangée = matrice[x];
Si (!row) casse calculate_sum;
pour (var y = 0; y < row.length; y ) {
                       var cell = row[y];
Si (isNaN(cell)) break computation_sum;
                     somme = cellule ;
                 }
                }
                      succès = vrai ;
            }
​​​​​​ //l'instruction break saute ici
//Si la condition success =false arrive ici, cela signifie qu'il y a une erreur dans la matrice que nous avons donnée
//Sinon, additionnez tous les éléments de la matrice

Enfin, il convient de noter que, que l'instruction break soit étiquetée ou non, son contrôle ne peut pas franchir les limites de la fonction. Par exemple : pour une instruction de définition de fonction avec une étiquette, vous ne pouvez pas utiliser cette étiquette pour accéder à l'extérieur de la fonction via l'intérieur de la fonction.

iii.continuer la déclaration

L'instruction continue est très similaire à l'instruction break, mais elle ne quitte pas la boucle, mais exécute à la place la boucle suivante. La syntaxe de l'instruction continue est aussi simple que la syntaxe de l'instruction break

continuer ;

L'instruction continue aura également des balises

continuer lebname;

Que l'instruction continue ait ou non une étiquette, elle ne peut être utilisée que dans le corps de la boucle. Si elle est utilisée ailleurs, une erreur de syntaxe sera signalée.
Lorsque l'instruction continue est exécutée, la logique de boucle actuelle est terminée et la boucle suivante est exécutée immédiatement. Dans différents types de boucles, le comportement de continue est également différent
. 1. Dans la boucle while, la spécification de l'expression au début de la boucle sera testée à plusieurs reprises. Si le résultat du test est vrai, le corps de la boucle sera exécuté depuis le début.
2. Dans la boucle do/while, l'exécution du programme passe à la fin de la boucle. À ce moment, la condition de la boucle sera réévaluée avant de passer à la boucle suivante.
3. Dans la boucle for, l'expression d'auto-incrémentation est d'abord calculée, puis l'expression de test est détectée pour déterminer s'il faut exécuter le corps de la boucle.
4. Dans la boucle for/in, la boucle commence à parcourir le nom d'attribut suivant, qui est attribué à la variable spécifiée.

Vous devez faire attention à la différence entre l'instruction continue dans les boucles while et for. La boucle while entre directement dans le prochain tour de jugement de condition de boucle, mais la boucle for calcule d'abord l'expression d'incrémentation, puis juge la condition de boucle. . Le chapitre précédent traitait du comportement « équivalent » d’une boucle for à une boucle while. Cependant, comme continue se comporte différemment dans ces deux boucles, il est impossible de simuler parfaitement l'équivalent d'une boucle for à l'aide d'une boucle while.

Le code suivant montre l'instruction continue sans étiquette, qui ignore la logique suivante de la boucle actuelle lorsqu'une erreur se produit

Copier le code Le code est le suivant :

pour (i = 0; i < data.length; i ) {
If (!data[i]) continue ; //Impossible de gérer les données non définies
                  total = data[i];
            }

Semblable à l'instruction break, l'instruction continue étiquetée peut être utilisée dans des boucles imbriquées pour sortir de la logique du corps de boucle imbriquée hiérarchiquement. Également similaire à l'instruction break, il ne peut pas y avoir de nouvelle ligne entre l'instruction continue et le nom du laboratoire.

iiii.retour

Rappelez-vous qu'un appel de fonction est une expression et que toutes les expressions ont des valeurs. L'instruction return dans une fonction fait référence à la valeur de retour après l'appel de la fonction. Voici la syntaxe de l'instruction return :

expression de retour ;

L'instruction return ne peut apparaître que dans le corps de la fonction. Sinon, une erreur de syntaxe sera signalée. Lorsque l'instruction return est exécutée, la fonction termine l'exécution et renvoie la valeur de l'expression au programme appelant. Par exemple :

Copier le code Le code est le suivant :

              function square(x) {return x * x} //Une fonction d'instruction contenant return
                 square(4) //L'exécution est 16

S'il n'y a pas d'instruction return, l'appel de fonction exécutera uniquement chaque instruction du corps de la fonction dans l'ordre jusqu'à la fin de la fonction, et reviendra finalement au programme appelant. Dans ce cas, le résultat de l’appel de l’expression n’est pas défini. L'instruction return apparaît souvent comme la dernière instruction d'une fonction, mais cela ne signifie pas nécessairement qu'elle doit être placée à la fin de la fonction, même s'il y a beaucoup de code qui n'a pas été exécuté lors de l'exécution de l'instruction return. , la fonction reviendra toujours au programme appelant.
L'instruction return peut être utilisée seule sans expression. Dans ce cas, la fonction voudra également appeler le programme et renvoyer undéfini. Par exemple :

.

Copier le code Le code est le suivant :

//Si le paramètre est nul ou indéfini, renvoie immédiatement
Si (!o) retourne ;
                                                                                                                                                                                                         // Autre logique

Étant donné que JavaScript peut insérer automatiquement des points-virgules, il ne peut pas y avoir de nouvelle ligne entre le mot-clé return et l'expression qui le suit.

iiiiii.throw déclaration

La soi-disant exception (exception) est un signal généré lorsqu'une situation anormale ou une erreur se produit. Lancer une exception signifie signaler qu'une erreur ou une condition anormale s'est produite. Attraper une exception signifie traiter le signal et lancer une exception, qui consiste à utiliser un signal pour notifier qu'une erreur ou une situation anormale s'est produite. Attraper une exception fait référence au traitement de ce signal, c'est-à-dire à la prise des mesures nécessaires pour récupérer de l'exception. En JavaScript, une exception est explicitement levée lorsqu'une erreur d'exécution se produit ou lorsque le programme utilise l'instruction throw. Les exceptions peuvent être interceptées à l'aide des instructions try/catch/finally, qui seront présentées en détail dans la section suivante.

La syntaxe de l'instruction throw est la suivante :

lancer une expression

La valeur de l'expression peut être de n'importe quel type. Peut lancer un tableau représentant les codes d'erreur ou une chaîne contenant un message d'erreur. Lorsque l'interpréteur JavaScript lève une exception, il utilise généralement le type Eeeor ou ses sous-types, mais ils peuvent également être utilisés. Un objet error a une représentation familière du type d'erreur et un attribut de message utilisé pour transmettre la chaîne au constructeur (voir la classe Error dans la partie 3. Dans l'exemple suivant, une erreur est levée lorsque la fonction est appelée avec illégal). paramètres. Objet :

Copier le code Le code est le suivant :

fonction fa(x) {
& nbsp

Déclaration：

Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn