Forcer la sortie de la boucle en javascript. Pour les boucles en JavaScript
Une boucle est une instruction de contrôle qui permet de répéter l'exécution du code d'un programme un certain nombre de fois. Chaque exécution individuelle d’instructions dans le corps d’une boucle est appelée une itération.
boucle while
Syntaxe de la boucle While :
L'expression entre parenthèses s'appelle condition de réalisation cycle ou conditionner brièvement. Tout d'abord, la valeur de l'expression est calculée. La valeur résultante est implicitement convertie en type booléen si nécessaire. Si le résultat de l'évaluation de l'expression est true , alors l'instruction située dans le corps de la boucle est exécutée, puis le contrôle est transféré au début de la boucle et la condition est à nouveau évaluée. Si le résultat de l’évaluation de l’expression est false , l’interpréteur termine la boucle et procède à l’exécution de l’instruction qui suit la boucle. Ainsi, l’interpréteur exécute encore et encore le code situé dans le corps de la boucle tant que la condition reste vraie :
Var je = 0 ; alors que je< 3) { // Выполнять код, пока значение переменной i меньше 3 alert("i: " + i); i++; // Увеличиваем значение переменной i }
faire une boucle en attendant
Syntaxe de la boucle Do-while :
Une boucle do-while est similaire à une boucle while, sauf que la condition de la boucle est vérifiée après la première itération plutôt qu'avant, et que la boucle se termine par un point-virgule. Puisque la condition est vérifiée après l'itération, le code dans le corps de la boucle do-while est toujours exécuté au moins une fois :
Nombre de variables = 0 ; faire ( document.write(count + " "); count++; ) while(count< 5); Попробовать »
Cette boucle peut être utile lorsque le code contenu dans le corps de la boucle doit être exécuté au moins une fois, quelle que soit la condition d'exécution.
pour la boucle
Syntaxe de la boucle For :
Une boucle for contient trois expressions séparées par des points-virgules. Ces trois expressions ont l'ordre d'exécution suivant :
- La première expression est toujours évaluée une seule fois, avant la première itération. Par conséquent, la première expression est généralement la définition d’une variable utilisée dans la condition d’exécution de la boucle comme compteur.
- La deuxième expression définit la condition d'exécution de la boucle. Il est calculé avant chaque itération et détermine si le corps de la boucle sera exécuté. Si l'expression est évaluée à vrai, le code dans le corps de la boucle est exécuté. Si false est renvoyé, la boucle se termine et le contrôle passe à l'instruction suivante après la boucle. Si la première fois que la condition est vérifiée, elle s'avère fausse, le code dans le corps de la boucle ne sera pas exécuté une seule fois.
- Après chaque itération, la troisième expression est évaluée. Généralement, il est utilisé pour modifier la valeur d'une variable utilisée pour tester l'état d'une boucle.
Exemple de boucle :
Pour (var count = 0; count< 5; count++) document.write(count + " "); Попробовать »
Comme vous pouvez le voir sur l'exemple, la boucle for, contrairement aux autres boucles, permet de regrouper le code associé à la boucle en un seul endroit.
N'importe laquelle des expressions de la boucle for peut manquer, mais les points-virgules eux-mêmes doivent être présents, sinon il y aura une erreur de syntaxe. Si la deuxième expression est manquante, la boucle s'exécutera indéfiniment.
Var je = 0 ; pour(;je< 4; i++) ... var i = 0; for (; i < 4;) ... for (var i = 1; /* нет условия */ ; i++) ... // Это эквивалентно следующему коду for (var i = 1; true; i++) ...
Au lieu d'une expression, vous pouvez spécifier plusieurs expressions, en les séparant par l'opérateur virgule.
// ne sera pas exécuté car la dernière expression de la vérification de condition est fausse pour (i = 1; i< 4, false; i++) ...
for (var i = 1, j = 5; i <= 5; i++, j--)
document.write(i + " " + j +"
"); Essayer "
boucle for-in
Une boucle for-in est utilisée pour parcourir les propriétés énumérées d'un objet dans un ordre aléatoire et a la syntaxe suivante :
Instruction For (variable dans l'objet) ;
À gauche du mot-clé in se trouve le nom d'une variable, à laquelle est attribué sous forme de chaîne le nom de l'une des propriétés de l'objet avant le début de chaque itération de la boucle. À droite du mot-clé in se trouve un objet dont les propriétés seront itérées dans la boucle. La boucle s'exécutera jusqu'à ce que toutes les propriétés disponibles aient été itérées. Si la variable représentant l'objet est nulle ou indéfinie, la boucle ne s'exécutera pas une seule fois :
Var obj = (x : 5, y : 10) ; pour (var prop dans obj) ( alert(prop); )
Pour conserver le code associé à une boucle au même endroit, vous pouvez déclarer une variable dans une boucle for-in. Par conséquent, l’expression précédant le mot-clé in est généralement une déclaration d’une variable à laquelle des noms de propriétés seront attribués.
Boucles JavaScript fournir une exécution répétée de calculs répétitifs. Ils optimisent le processus de codage en exécutant la même instruction ou le même bloc d'instructions qui forment le corps d'une boucle un nombre de fois spécifié (à l'aide d'une variable de compteur) ou lorsqu'une condition spécifiée est vraie. Les boucles parcourent une séquence de valeurs. Exécuter une boucle une fois est appelé itération.
Les performances d'une boucle sont affectées par le nombre d'itérations et le nombre d'opérations effectuées dans le corps de la boucle de chaque itération.
Les opérateurs de boucle suivants existent en JavaScript :
1) for est utilisé lorsque vous savez à l'avance combien de fois vous devez faire quelque chose ;
2) for...in est utilisé pour parcourir les propriétés des objets ;
3) while est utilisé lorsque vous ne savez pas combien de fois vous devez faire quelque chose ;
4) do... while fonctionne de la même manière que l'instruction while. La différence est que do... while exécute toujours l'expression entre les accolades au moins une fois, même si le test de condition renvoie false .
Types de boucles en JavaScript, contrôle de boucle
1. Pour la boucle
La boucle for est utilisée pour parcourir les éléments de tableaux ou d'objets de type tableau tels que les arguments et HTMLCollection. La condition est vérifiée avant chaque itération de la boucle. Si la vérification réussit, le code à l'intérieur de la boucle est exécuté, sinon le code à l'intérieur de la boucle n'est pas exécuté et le programme continue à partir de la première ligne suivant immédiatement la boucle.
La boucle suivante imprimera la ligne Hello, JavaScript ! Cinq fois.
Pour (var je = 0; je< 5; i++) {
console.log(i + ": Hello, JavaScript!");
}
Riz. 1. Résultat de l'exécution d'une boucle for sur la console
1.1. Comment fonctionne la boucle for
La boucle for se compose de trois opérations différentes :
Étape 1. initialisation var je = 0; — déclaration d'une variable compteur qui sera vérifiée lors de l'exécution de la boucle. Cette variable est initialisée avec la valeur 0. Le plus souvent, les variables nommées i, j et k agissent comme des compteurs de boucles.
Étape 2. vérification de l'état je< 5; — условное выражение, если оно возвращает true , тело цикла (инструкция в фигурных скобках) будет выполнено. В данном примере проверка условия идёт до тех пор, пока значение счётчика меньше 5 .
Étape 3. opération finale i++ - opération d'incrémentation du compteur, augmente la valeur de la variable var i de un. Au lieu de l’opération d’incrémentation, l’opération de décrémentation peut également être utilisée.
A la fin de la boucle, la variable var i est stockée à 1. L'itération suivante de la boucle est exécutée pour (var i = 1; i< 5; i++) { } . Условное выражение вычисляется снова, чтобы проверить, является ли значение счётчика i всё ещё меньше 5 . Если это так, операторы в теле цикла выполняются ещё раз. Завершающая операция снова увеличивает значение переменной на единицу. Шаги 2 и 3 повторяются до тех пор, пока условие i < 5; возвращает true .
1.2. Impression des valeurs du tableau
Pour imprimer les valeurs d'un tableau à l'aide d'une boucle for, vous devez utiliser la propriété length du tableau. Cela vous aidera à déterminer le nombre d'éléments dans le tableau et à boucler le même nombre de fois.
Le script ci-dessous affichera cinq messages avec les noms des couleurs :
Fleurs du Var = ["Rose", "Lis", "Tulipe", "Jasmin", "Orchidée"]; pour (var je = 0; je< flowers.length; i++){ alert(flowers[i] + " - это цветок."); }
Si la valeur de la propriété length ne change pas pendant la boucle, vous pouvez la stocker dans une variable locale, puis utiliser cette variable dans une expression conditionnelle. De cette façon, vous pouvez augmenter la vitesse de la boucle, puisque la valeur de la propriété length ne sera récupérée qu'une seule fois pendant toute la durée de la boucle.
Var flowers = ["Rose", "Lis", "Tulipe", "Jasmin", "Orchidée"], len = flowers.length; pour (var je = 0; je
2. Boucle pour...in
Les boucles For...in sont utilisées pour parcourir les propriétés des objets non-tableaux. Ce contournement est également appelé transfert. Lors du parcours, il est recommandé d'utiliser la méthode hasOwnProperty() pour filtrer les propriétés héritées du prototype.
Par exemple, créons un objet en utilisant un littéral d'objet.
Var user = ( nom : "Alice", âge : 25, pays : "Russie" ); for (var prop in user) ( console.log(prop + ": " + user); ) 
Riz. 2. Résultat de l'exécution de la boucle for...in sur la console
Supposons que dans un scénario avant ou après la création de l'objet utilisateur, le prototype de l'objet Object ait été étendu avec une méthode clone() supplémentaire.
Si (type d'Object.prototype.clone === "indéfini") ( Object.prototype.clone = function () (); )
Étant donné que la chaîne d'héritage du prototype est constamment vérifiée par l'interpréteur, tous les objets ont automatiquement accès à la nouvelle méthode.
Riz. 3. Résultat de la répétition de la boucle for...in sur la console Pour éviter la détection de cette méthode lors de l'énumération des propriétés de l'objet utilisateur, la méthode hasOwnProperty() est utilisée, qui filtrera les propriétés du prototype.
Var user = ( nom : "Alice", âge : 25, pays : "Russie" ); if (typeof Object.prototype.clone === "indéfini") ( Object.prototype.clone = function () (); ) for (var prop in user) ( if (user.hasOwnProperty(prop)) ( console.log (prop + ": " + utilisateur); ) ) 
Riz. 4. Le résultat de la liste des propriétés d'un objet à l'aide de la méthode hasOwnProperty()
3. Boucle while
La boucle while est une boucle avec une vérification préliminaire d'une expression conditionnelle. L'instruction à l'intérieur de la boucle (bloc de code entre accolades) sera exécutée si l'expression conditionnelle est évaluée à true . Si la première vérification renvoie false , le bloc d'instructions ne sera pas exécuté une seule fois.
Une fois l'itération de la boucle terminée, la vérité de l'expression conditionnelle est à nouveau testée et le processus est répété jusqu'à ce que l'expression soit évaluée comme false . Dans ce cas, le programme continuera à partir de la première ligne immédiatement après la boucle (s'il y en a une).
Cette boucle affichera la table de multiplication du nombre 3 :
Var je = 1 ; var msg = ""; alors que je< 10) {
msg+= i + " x 3 = " + (i * 3) + "
"; i++; ) document.write(msg); 
Riz. 5. Résultat de l'exécution de la boucle while
4. Faites... while en boucle
Boucle faire... while ; vérifie la condition de continuation après l'exécution de la boucle. Contrairement à la boucle while, dans do... while; Le corps de la boucle est exécuté au moins une fois, puisque la condition est vérifiée à la fin de la boucle, et non au début. Cette boucle est utilisée moins fréquemment que while , car en pratique, une situation où au moins une exécution de boucle est requise est rare.
Var résultat = "" ; var je = 0; faire ( je += 1; résultat += je + " "; ) tandis que (je< 5);
document.write(result);
Riz. 6. Résultat de l'exécution de la boucle do...while
Dans l'exemple suivant, les instructions d'une boucle sont exécutées une fois, même si la condition n'est pas vraie.
Var je = 10 ; faire ( document.write(i + " "); i++; ) tandis que (i< 10);
5. Boucles infinies
Lorsque vous créez une boucle, vous pouvez créer une boucle infinie qui ne finira jamais. Une telle boucle pourrait potentiellement continuer à s'exécuter tant que l'ordinateur de l'utilisateur est en marche. La plupart des navigateurs modernes peuvent le détecter et inviter l'utilisateur à arrêter d'exécuter le script. Pour éviter de créer une boucle infinie, vous devez être sûr que la condition donnée renverra false à un moment donné. Par exemple, la boucle suivante spécifie une condition qui ne renvoie jamais false car i ne sera jamais inférieur à 10 :
Pour (var i = 25; i > 10; i++) ( document.write("Cette phrase s'exécutera pour toujours...
");
}
6. Boucles imbriquées
Une boucle à l’intérieur d’une autre boucle s’appelle imbriqué. A chaque itération de la boucle, la boucle imbriquée est exécutée complètement. Des boucles imbriquées peuvent être créées à l’aide d’une boucle for et d’une boucle while.
Pour (var count = 1; count< 3; count++) {
document.write(count + ". Строка цикла
" ); pour (var nombre de nids = 1 ; nombre de nids< 3; nestcount++) {
document.write("Строка вложенного цикла
");
}
}
Riz. 7. Résultat de l'exécution d'une boucle for imbriquée
7. Gestion des cycles
La boucle peut être contrôlée à l'aide d'instructions break ; et continue; .
7.1. Pause opérateur ;
Pause opérateur ; termine l'exécution de la boucle en cours. Il est utilisé dans des cas exceptionnels lorsque la boucle ne peut pas s'exécuter pour une raison quelconque, par exemple si l'application rencontre une erreur. Le plus souvent l'opérateur de pause ; fait partie de la construction if.
Lorsque la déclaration est interrompue ; utilisé sans étiquette, il vous permet de quitter une instruction loop ou switch. L'exemple suivant crée un compteur dont les valeurs doivent être comprises entre 1 et 99, mais l'instruction break rompt la boucle après 14 itérations.
Pour (var je = 1; je< 100; i++) {
if (i == 15) {
break;
}
document.write(i);
document.write("
");
}
Riz. 8. Le résultat de l'opérateur break dans la boucle for
Pour les boucles imbriquées, l'instruction break ; utilisé avec une étiquette qui termine l'instruction nommée. Une étiquette vous permet de quitter n’importe quel bloc de code. Une instruction nommée peut être n’importe quelle instruction externe à une instruction break ; . L'étiquette peut être le nom d'une instruction if ou le nom d'un bloc d'instructions entouré d'accolades juste pour attribuer une étiquette à ce bloc. Entre le mot-clé break ; et le nom de l'étiquette n'autorise pas de nouvelle ligne.
Boucle extérieure : pour (var je = 0 ; je< 10; i++) {
innerloop:
for(var j = 0; j < 10; j++) {
if (j >3) pause ; // Quitte la boucle la plus interne if (i == 2) break innerloop; // Même chose si (i == 4) break externalloop ; // Quitte la boucle externe document.write("i = " + i + " j = " + j + "
"); ) ) document.write("FINAL i = " + i + " j = " + j + "
");
7.2. L'opérateur continue ;
L'opérateur continue ; arrête l'itération en cours de la boucle et démarre une nouvelle itération. Dans ce cas, la boucle while revient directement à sa condition et la boucle for évalue d'abord l'expression d'incrémentation puis revient à la condition.
Cet exemple affichera tous les nombres pairs :
Var je; pour (je = 1; je<= 10; i++) {
if (i % 2 !== 0) {
continue;
}
document.write("
nombre pair= " + je); ) 
Riz. 9. Le résultat de l'opérateur continue dans la boucle for
L'opérateur continue ; peut également être utilisé dans des boucles imbriquées avec une étiquette.
Boucle extérieure : pour (var i = 0; i "); pour (var j = 0; j "); ) ) document.write("Toutes les boucles terminées"+"
");
Riz. 10. Le résultat de l'opérateur continue avec une étiquette
L'histoire de la formation de la syntaxe des langages de programmation modernes s'apparente à la compréhension des processus de formation de l'Univers. Quoi et comment c'était au début... Mais maintenant tout est simple et accessible.
En fin de compte, l’algorithme est toujours une chaîne de commandes séquentielle. Le parallélisme en programmation est un ensemble de séquences combinées d’une manière ou d’une autre. la chaîne de commandement en série ou en parallèle n'a jamais été aussi pratique. Étiquettes, transitions et conditions - tout était suffisant pour n'importe quelle solution. Les langages fonctionnels ont rendu ces idées inutiles, mais la nécessité de répéter des sections de code demeure.
Navigateur : DOM, son langage + serveur
En JavaScript, les boucles subsistent, même si les idées fonctionnelles ont acquis une signification particulière. Il reste peut-être quelque chose de "Lisp" et "Prolog", mais très probablement la zone où réside JavaScript a conduit à ce qui est là, mais il est douteux que ce soit la dernière solution.
JavaScript s'exécute dans le navigateur, qui reçoit la page, l'analyse dans le DOM et exécute le premier script. Toutes les autres pages, y compris celles chargées sur celle-ci, sont l'œuvre du développeur manipulant le langage, à travers lequel le code sur le serveur peut être appelé et le résultat obtenu à l'aide du mécanisme AJAX.
Le navigateur exécute du code JavaScript, qui peut utiliser des objets du navigateur, y compris celui qui transmet des informations au serveur et reçoit une réponse, qui peut être un balisage HTML, des styles et le code lui-même. La réponse peut être représentée par des tableaux et des objets. L'intérêt d'utiliser des boucles en JavaScript est perdu, il existe de nombreuses possibilités de s'en passer, et le risque de bloquer le navigateur avec une séquence de commandes sans fin n'est pas la meilleure solution.
Les boucles elles-mêmes sont présentes dans la plupart des constructions syntaxiques JavaScript ; le développeur peut compléter les constructions standard avec ses propres fonctions.
Position de JavaScript dans l'espace de code
Un programmeur moderne ne pense même pas que le while, do while, ...) qu'il utilise est en fin de compte une série de cycles de processeur, une simple séquence d'opérations binaires, interrompue par des contre-vérifications, c'est-à-dire des conditions.
Il n'y a pas de boucle en tant que telle au niveau du langage machine : il existe une combinaison de commandes ordinaires, d'opérations conditionnelles et de transitions. Un niveau supérieur, quel que soit l'outil utilisé pour développer le navigateur et l'interpréteur JavaScript, il y aura certainement des boucles. De plus, des « morceaux de code » seront présentés à différents moments et par différentes générations de programmeurs. L'étage au-dessus est le "bâtiment" JavaScript. Dont la syntaxe propose des boucles JavaScript modernes.
JS est un langage merveilleux : pratique, moderne et complet. La syntaxe de cet outil inclut toutes les constructions qui ont résisté à l’épreuve du temps et sont devenues le fondement inébranlable de tout algorithme. Mais les cycles sont-ils vraiment nécessaires ? Les progrès de la programmation se sont souvent posés des questions fondamentales, mais ils n'ont trouvé de solution que dans certains cas.
Motifs objectifs
Un cycle ne peut avoir que deux options : par condition ou par compteur, mais essentiellement (au niveau le plus bas) tout cycle est uniquement par condition. Dans certaines langues, il existe un cycle "pour chacun". En JavaScript, les boucles foreach sont représentées par le prop dans la construction d'objet, mais vous pouvez utiliser la variante array.forEach(...).
Dans tous les cas, il y a deux options : le programmeur qui exécute finalement tous les algorithmes du programmeur, même ceux écrivant dans des langages interprétatifs, n'a pas d'autres options pour répéter la chaîne de commandes : il peut exécuter à nouveau quelque chose jusqu'à :
- le compteur compte ;
- pour autant que la condition soit remplie.
JavaScript est un interpréteur typique. Sa particularité : il fonctionne à l'intérieur du navigateur, utilise ses objets et permet d'exécuter des algorithmes côté client, aussi bien au chargement de la page dans le navigateur que pendant son fonctionnement.
Boucle simple une par une
En JavaScript, les boucles foreach ressemblent à l'application d'une fonction à un tableau :
L'utilisation de tels cycles ne pose aucune difficulté. Formellement, il n’existe pas de cycle en tant que tel. Il existe un appel de fonction séquentiel aux éléments du tableau.
Boucle sur un comptoir
Les boucles For semblent plus familières en JavaScript :
Ici le compteur est une variable dont la valeur change selon une formule et une condition est un signe de fin de cycle. La formule et la condition n'ont pas besoin d'inclure une variable de boucle. Mais le contrôle sur le moment où le cycle se termine est entièrement déterminé par son contenu.
Boucles conditionnelles
JavaScript propose une option avec while selon le moment où la condition doit être vérifiée. Si le corps de la boucle ne peut pas être exécuté une seule fois, c'est une chose ; si le corps doit être exécuté au moins une fois, c'est une autre :
Dans le premier cas, lors de l'interprétation de la construction while, JavaScript vérifie d'abord la condition, et si elle est vraie, il exécute la boucle. Dans le second cas, la boucle sera exécutée en premier. Si, suite à la modification des variables spécifiées dans les conditions de conception faites pendant, il sera évalué à false et la boucle cessera de s'exécuter.
Combinaisons massives d'algorithmes simples
La tâche principale (composante) de tout algorithme est de trouver, puis de prendre une décision sur la marche à suivre ensuite. L'option de recherche la plus primitive consiste à accéder à une variable, le résultat est obtenu directement. S'il existe de nombreuses variables ou s'il a plusieurs valeurs (un tableau), alors pour sélectionner une valeur, il est nécessaire de trouver quelque chose qui déterminera le comportement ultérieur du script.
Une doctrine si simple faite une boucle avec un compteur en JavaScript est une sorte de panacée à tous les problèmes. Les ordinateurs modernes sont rapides. Vous disposez de suffisamment de temps pour exécuter des scripts dans le navigateur, vous n'avez pas besoin de vous précipiter. Il est plus facile que jamais de vivre quelque chose pour le plaisir de quelque chose. En conséquence, le J AvaScript pour les boucles est devenu très populaire.
Il ne semble y avoir rien de mal à cela. Mais derrière cette approche, l'essence pour laquelle tel ou tel algorithme est écrit se perd facilement. Les données n’ont pas de sens. Tout ce pour quoi un programme est écrit a un sens. Utilisation excessive sur J avaScript pour les boucles, le développeur peut ne pas reconnaître l'entité requise et ne pas créer un algorithme adéquat.
La fonctionnalité, un autre reflet de la réalité
Candidature Boucles JavaScript, exemplesle code du même type peut être représenté par des fonctions - l'algorithme se transformera immédiatement, le corps principal du script diminuera en taille, tout deviendra lisible et compréhensible.
Il ne s’agit pas d’une solution radicalement nouvelle, mais, par essence, elle ne va pas au-delà des autres constructions linguistiques. En particulier, J. Les boucles AvaScript peuvent être trouvées dans la fonction classique split() :
var cRésultat = "9,8,7,6,5,4" ;
var aResult = cResult .split ( "," );
Il n'y a pas de boucle ici, mais comment cela peut-il être accompli autrement qu'en recherchant le symbole "," et en l'utilisant pour séparer un nombre d'un autre.
En faisant abstraction de la façon dont cela est implémenté dans la fonction split(), vous pouvez compléter JavaScript avec votre propre fonctionnalité qui utilise des boucles, ce qui est plus pratique du point de vue de l'utilisation. Il est important que cette approche conduise au développement de fonctionnalités pour chaque tâche, respectivement, mais le général restera toujours avec cette approche.
Ces fonctions allt(), padc(), padl() et padr() sont quelque chose que JavaScript n'a pas, mais vous devez parfois supprimer des espaces d'une chaîne ou aligner la longueur d'une chaîne à gauche, à droite ou des deux côtés. Les corps de ces fonctions contiennent des boucles JavaScript. Simple, accessible et l'algorithme qui l'utilise ne plantera jamais.
Des variantes de fonctions permettant de convertir des nombres de l'hexadécimal au système numérique 10 et vice versa, plus simplement, d'un format de données à un autre, sont exécutées ici à l'aide de boucles do while. Syntaxe du langage très compacte et efficace.
Cycles corrects - reflet de la réalité
JavaScript n'est pas à la hauteur des autres langages de programmation et ne diffère pas par la variété des versions et, surtout, il s'efforce de ne pas modifier la syntaxe, mais de la développer et de l'étendre.
L'état d'esprit d'un programmeur utilisant JS est différent de la pensée d'un programmeur PHP (en particulier, et d'autres langages en général, sauf que « Prolog » et ses adeptes ne sont pas inclus dans le grand public), lorsque l'algorithme n'est pas limité aux variables, aux tableaux, aux opérateurs d'affectation et aux constructions cycliques.
Si nous imaginons qu'il n'y a pas de cycles, mais que le problème doit être résolu, alors l'option la plus simple (les yeux bandés) consiste à supposer que le programme traite des données qui sont un point ou un système de points dans l'espace d'information. Ce qu'est un point et ce qu'est un système de points dépend d'un domaine spécifique. Pour un programmeur, cette thèse signifie : il existe une donnée simple et il existe une collection de données simples. Naturellement, une simple donnée d'un niveau sera un système pour un niveau inférieur et un point pour un niveau supérieur.
Avec cette approche, le souci du point est de manifester son essence à travers ses méthodes. Lorsqu'un point se trouve dans un supersystème, alors la fonction du système est de manifester son essence comme un ensemble d'essences des points qui y sont inclus.
Cette approche est aussi ancienne que l'idée des langages de programmation, mais n'a pas encore été suffisamment reflétée dans la programmation. De nombreux programmeurs pensent correctement, mais le résultat de leur créativité laisse beaucoup à désirer.
Cela aide parfois de porter un bandeau sur les yeux pour voir le monde !
Cycles
Pour comprendre l’effet des instructions conditionnelles, nous avons suggéré de les imaginer comme des bifurcations sur la route le long desquelles se déplace l’interpréteur JavaScript. Les boucles peuvent être considérées comme un demi-tour sur la route qui vous ramène, obligeant l’interprète à parcourir encore et encore le même morceau de code.
JavaScript comporte quatre boucles : while, do/while, for et for/in. Une des sous-sections suivantes est consacrée à chacun d’eux. Une utilisation courante des boucles consiste à parcourir les éléments d’un tableau.
boucle while
L'instruction if est l'instruction conditionnelle de base en JavaScript, et la boucle de base pour JavaScript est la boucle while. Il a la syntaxe suivante :
while (expression) (instruction)
La boucle while commence par évaluer une expression. Si cette expression est évaluée comme fausse, l'interpréteur ignore l'instruction qui constitue le corps de la boucle et passe à l'instruction suivante du programme. Si l'expression est évaluée comme vraie, alors l'instruction qui forme le corps de la boucle est exécutée, puis le contrôle est transféré au début de la boucle et l'expression est à nouveau évaluée. En d’autres termes, l’interpréteur exécute l’instruction du corps de la boucle encore et encore tant que la valeur de l’expression reste vraie. Veuillez noter qu'il est possible de créer une boucle infinie en utilisant la syntaxe while(true).
En règle générale, vous ne souhaitez pas que l'interpréteur JavaScript effectue la même opération encore et encore. Dans presque chaque boucle, à chaque itération de la boucle, une ou plusieurs variables changent de valeur. Étant donné que la variable change, ce que fait l’instruction peut différer à chaque fois qu’elle traverse le corps de la boucle.
De plus, si la ou les variables en cours de modification sont présentes dans l'expression, la valeur de l'expression peut changer à chaque passage de la boucle. C'est important parce que sinon l'expression dont la valeur était vraie ne changera jamais et la boucle ne se terminera jamais ! Vous trouverez ci-dessous un exemple de boucle while qui imprime les nombres de 0 à 9 :
Nombre de variables = 0 ; tandis que (compter
Comme vous pouvez le voir, la variable count est définie sur 0 au début, puis sa valeur est incrémentée à chaque fois que le corps de la boucle est exécuté. Une fois la boucle exécutée 10 fois, l'expression renverra false (c'est-à-dire que la variable count n'est plus inférieure à 10), l'instruction while se terminera et l'interpréteur passera à l'instruction suivante du programme. La plupart des boucles ont des variables de compteur similaires à count. Le plus souvent, les variables nommées i, j et k agissent comme des compteurs de boucles, bien que pour rendre le code du programme plus compréhensible, vous devez donner aux compteurs des noms plus descriptifs.
faire/pendant la boucle
Une boucle do/while est similaire à bien des égards à une boucle while, sauf que l'expression de la boucle est testée à la fin plutôt qu'au début. Cela signifie que le corps de la boucle est toujours exécuté au moins une fois. Cette instruction a la syntaxe suivante :
faire (déclaration) while (expression);
La boucle do/while est utilisée moins fréquemment que sa sœur while. Le fait est qu'en pratique, la situation dans laquelle vous êtes sûr à l'avance de devoir exécuter le corps de la boucle au moins une fois est quelque peu inhabituelle. Vous trouverez ci-dessous un exemple d'utilisation d'une boucle do/while :
Fonction printArray(a) ( var len = a.length, i = 0; if (len == 0) console.log("Empty array"); else ( do ( console.log(a[i]); ) while (++je
Il existe deux différences entre une boucle do/while et une boucle while normale. Premièrement, une boucle do nécessite à la fois le mot-clé do (pour marquer le début de la boucle) et le mot-clé while (pour marquer la fin de la boucle et spécifier une condition). Deuxièmement, contrairement à une boucle while, une boucle do se termine par un point-virgule. Une boucle while n'a pas besoin de se terminer par un point-virgule si le corps de la boucle est entouré d'accolades.
pour la boucle
Une boucle for est une construction de boucle qui est souvent plus pratique qu’une boucle while. La boucle for facilite la construction de boucles qui suivent un modèle commun à la plupart des boucles. La plupart des boucles ont une sorte de variable compteur. Cette variable est initialisée avant le démarrage de la boucle et est vérifiée avant chaque itération. Enfin, la variable compteur est incrémentée ou autrement modifiée à la fin du corps de la boucle, juste avant que la variable ne soit à nouveau vérifiée. L'initialisation, la vérification et la mise à jour sont les trois opérations clés effectuées sur une variable de boucle. L'instruction for rend ces trois étapes explicites dans la syntaxe de la boucle :
pour (initialisation; vérification; incrément) (instruction)
Initialiser, vérifier et incrémenter sont trois expressions (séparées par des points-virgules) responsables de l'initialisation, de la vérification et de l'incrémentation d'une variable de boucle. Les placer sur la première ligne de la boucle permet de mieux comprendre ce que fait la boucle for et vous évite d'oublier d'initialiser ou d'incrémenter une variable de boucle.
La façon la plus simple d'expliquer la boucle for est d'afficher la boucle while équivalente :
initialisation ; while(check) ( instruction; incrément; )
En d’autres termes, l’expression d’initialisation est évaluée une fois avant le début de la boucle. Cette expression est généralement une expression avec des effets secondaires (généralement une affectation). JavaScript permet également à l'expression d'initialisation d'être une instruction de déclaration de variable var, il est donc possible de déclarer et d'initialiser un compteur de boucles en même temps.
L'expression de test est évaluée avant chaque itération et détermine si le corps de la boucle sera exécuté. Si le résultat du test est vrai, l'instruction qui constitue le corps de la boucle est exécutée. A la fin de la boucle, l'expression d'incrément est évaluée. Pour que cette expression ait un sens, il faut qu’elle ait des effets secondaires. Il s'agit généralement soit d'une expression d'affectation, soit d'une expression utilisant l'opérateur ++ ou --.
Vous pouvez également imprimer les nombres de 0 à 9 à l'aide d'une boucle for, comme indiqué ci-dessous, par opposition à la boucle while équivalente présentée dans l'exemple précédent :
Pour (var count = 0; count
Bien entendu, les boucles peuvent être beaucoup plus complexes que ces exemples simples, et parfois plusieurs variables changent à chaque itération de la boucle. Cette situation est la seule fois en JavaScript où l'opérateur virgule est souvent utilisé - il vous permet de combiner plusieurs expressions d'initialisation et d'incrémentation en une seule expression pouvant être utilisée dans une boucle for :
Var je,j; pour (i = 0, j = 0; je
boucle for/in
La boucle for/in utilise le mot-clé for, mais elle est complètement différente d'une boucle for classique. La boucle for/in a la syntaxe suivante :
pour (variable dans l'objet) (instruction)
La variable ici est généralement le nom de la variable, mais vous pouvez également utiliser l'instruction var, qui déclare une seule variable. Le paramètre objet est une expression qui renvoie un objet. Et comme d’habitude, une instruction est une instruction ou un bloc d’instructions qui forme le corps d’une boucle.
Pour parcourir les éléments d’un tableau, il est naturel d’utiliser une boucle for régulière :
Var arr = ; pour (var je = 0; je
L'instruction for/in permet aussi naturellement de parcourir les propriétés d'un objet :
// Crée un nouvel objet var obj = (name:"Alex", password:"12345" ); for (var i in obj) ( // Imprimer la valeur de chaque propriété d'objet console.log(obj[i]); )
Pour exécuter une instruction for/in, l'interpréteur JavaScript évalue d'abord l'objet expression. S'il renvoie null ou undefined, l'interpréteur saute la boucle et passe à l'instruction suivante. Si l'expression renvoie une valeur simple, elle est convertie en un objet wrapper équivalent. Sinon, l'expression renvoie un objet. L'interpréteur exécute ensuite une itération de la boucle pour chaque propriété énumérable de l'objet. Avant chaque itération, l'interpréteur évalue la valeur de l'expression, la stocke dans une variable et lui attribue un nom de propriété (une valeur de chaîne).
