souvent
contrôler l'ordre d'exécution du code pour réaliser les fonctions que nous souhaitons exécuter.
: le contrôle de flux consiste à nous contrôler dans quel ordre le code écrit doit être exécuté pour atteindre notre objectif.
Il existe trois structures principales dans le contrôle de processus : la structure séquentielle, la structure de branche et la structure de boucle. Ces trois structures représentent l'ordre d'exécution du code.
La structure séquentielle est le contrôle de processus le plus simple et le plus basique du programme. Les codes que nous avons écrits auparavant appartiennent tous à la structure séquentielle (c'est-à-dire qu'ils sont exécutés de haut en bas). ordre du code.Dans l'ordre,
le processus d'exécution du code de haut en bas, différents codes de chemin sont exécutés selon différentes conditions (le processus de sélection de l'un des multiples codes d'exécution), obtenant ainsi résultats différents.1.21
Le langage js fournit deux structures de branche.Instruction
// Exécuter le code si la condition est vraie, sinon ne rien faire
if (expression conditionnelle) {
//Langage de code pour l'exécution lorsque la condition est établie == Exécuter uniquement lorsque l'expression conditionnelle est vraie
}
Une instruction peut être comprise comme un comportement. Les instructions de boucle et les instructions de branchement sont des instructions typiques. Un programme se compose de plusieurs instructions. , il sera divisé en
Démonstration du code
d'instruction un par unvar age=19;
si(âge>=18){
console.log('Vous êtes un adulte');
// Indique que vous êtes déjà adulte, car age=19 ;, s'il est supérieur à 18, l'instruction dans if sera exécutée }
var âge=1 ;
si(âge>=18){
console.log('Vous êtes un adulte');
// Ne produit rien. age=1;<18, l'instruction dans if ne sera pas exécutée, il n'y a donc pas de processus d'exécution
}
la structure syntaxique
// Si la condition est établie, exécutez le code dans if, sinon exécutez le code dans else
if (expression conditionnelle) {
//Code à exécuter qui remplit les conditions
}else{
//Code ne remplissant pas les conditions d'exécution
}
Processus d'exécution
Démonstration de code
var age=prompt('Veuillez entrer votre âge');//Entrée utilisateur if(age>=18){
console.log('Vous pouvez boire maintenant');
}autre{
console.log('Désolé, les mineurs ne peuvent boire que du calcium AD');
}
//Déterminez si l'année est une année d'exécution var year=prompt('Veuillez entrer l'année :');
si(année%4==0&&année%100!=0||année%400==0){
alert('L'année que vous avez saisie est une année bissextile');
}autre{
alert('L'année que vous avez saisie est une année ordinaire');
} structure syntaxique
// Convient pour vérifier plusieurs conditions
if (expression conditionnelle) {
Instruction 1 ;
}else if(expression conditionnelle){
Instruction 2 ;
}else if(expression conditionnelle){
Déclaration 3 ;
…
}autrement{
//Exécuter ce code si les conditions ci-dessus ne sont pas remplies
}
Contrôle de processus
Démonstration de code
//Mini calculatrice : saisissez deux nombres et symboles d'opération pour obtenir le correspondant
var yi = +prompt('Veuillez entrer le premier nombre'); //Veuillez utiliser l'addition, la soustraction, la multiplication et la division pour convertir implicitement en type numérique, ou utiliser praseInt (variable) ou parsefloat (variable) des entiers et des nombres à virgule flottante var fuhao = prompt( 'Veuillez entrer l'opérateur');
var er = +prompt('Veuillez entrer le deuxième numéro');
si (fuhao == '+') {
var shu = yi + euh ;
} sinon if (fuhao == '-') {
var shu = yi - euh ;
} sinon if (fuhao == '/') {
var shu = yi/er ;
} sinon if (fuhao == '*') {
var shu = yi * euh;
} sinon si (fuhao == '%') {
var shu = yi % euh ;
} autre {
alert('Veuillez entrer comme requis :');
}
alert(shu); L'instruction switch est également une instruction multi-branches. Elle est utilisée pour exécuter différents codes en fonction de différentes conditions. Lorsque vous souhaitez définir une série de valeurs spécifiques pour les variables, switch switch
( expression) {
case value1 :
//Le code à exécuter lorsque l'expression est égale à value1
break ;
case value2 :
//
Le codeà
exécuter lorsque l'expression est égale à value2
break ;
n'est égal à aucune valeur
}
Contrôle du processus
Démonstration du code
var fruit =prompt('Veuillez entrer le fruit que vous souhaitez acheter :');
changer(fruit){
cas 'pomme' :
alert('Le prix des pommes est de : 3,5/catty');
casser;
cas 'litchi' :
alert('Le prix des litchis est de : 10,5/jin');
casser;
défaut:
alert('Pas de fruit');
} Notez
La différence entre l'instruction switch et if else if
En
général, les deux instructions peuvent être converties l'une dans l'autre.
la situation où le cas est une comparaison pour déterminer la valeur, tandis que l'instruction if...else... est plus flexible, souvent utilisée pour le jugement de plage (supérieur à, égal à une certaine plage).
L'instruction switch effectue un jugement conditionnel et)
exécute directement l'instruction conditionnelle du programme, ce qui est plus efficace. Cependant, les instructions if...else... ont plusieurs conditions et doivent être jugées plusieurs fois.
Lorsqu'il y a moins de branches, l'efficacité d'exécution de l'instruction if...else... est supérieure à celle de l'instruction switch.
Lorsqu'il y a de nombreuses branches, l'efficacité d'exécution de l'instruction switch est plus élevée et la structure est plus claire. .
dans les problèmes pratiques, il existe de nombreuses régularités. Par conséquent, pour effectuer de telles opérations dans le programme, vous devez exécuter à plusieurs reprises certaines instructions
dans Js
Instructions de boucle :
dans le programme, un groupe d'instructions exécutées à plusieurs reprises est appelé corps de boucle. Le fait qu'il puisse continuer à être exécuté à plusieurs reprises dépend des conditions pour. Terminaison de la boucle.L'instruction
composée du corps de la boucle et de la condition de fin de la boucle est appelée une instruction de boucle.
Lastructure syntaxique
de la boucle for est principalement utilisée pour répéter plusieurs fois certains codes, généralement liés au comptage. La structure de l'instruction est la suivante
pour (variable d'initialisation ; expression conditionnelle ; expression d'opération) {
//Corps de la boucle
}
contrôle de processus
Démonstration de code
pour (var i=1;i<=10;i++){
console.log('Est-ce que tu m'aimes ?');
}//Calculez le score total de la classe et le score moyen var num = prompt('Veuillez saisir le nombre total de personnes dans la classe')
var somme = 0,
moyenne = 0 ;
pour (var je = 1; je <= num; i++) {
var score = prompt('Veuillez saisir le score de l'élève ' + i + '')
//Les données extraites de l'invite sont une chaîne et doivent être converties en une somme numérique += parseInt(score);
}
moyenne = somme / nombre ;
alert('Score total de la classe :' + somme);
alert('Score moyen de la classe :' + somme);//Imprimer 5 cœurs sur une ligne pour (var i=0;i<=4;i++){
console.log('*');
} Boucle for double couche (imbrication de boucles)
L'imbrication de boucles fait référence à la structure grammaticale de la définition d'une instruction de boucle dans une instruction de boucle. Par exemple, l'imbrication d'une boucle for dans une boucle for. Nous appelons une telle instruction de boucle for Double couche for. loop
Nous appelons la boucle interne la boucle interne et la boucle externe la boucle externe. La
boucle externe boucle une fois et la boucle interne est exécutée du début à la fin.
Démonstration de code
// Bas niveau : 5 lignes et 5 colonnes var str. ='';
pour (var i=0;i<=4;i++){
pour (var j=0;j<=4;j++){
str+='*';
}
str+='n';
}
console.log(str);
//Avancé : n lignes et n colonnes var rows = prompt('Veuillez entrer le nombre de lignes :');
var cols = prompt('Veuillez entrer le nombre de colonnes');
var str='';
pour (var i = 1; i <= lignes; i++) {
pour (var j = 1; j <= cols; j++) {
str+='*';
}
str+='n';
}
console.log(str);
//Imprimer le triangle inversé var str='';
pour (var i=1;i<=10;i++){
pour (var j=i;j<=10;j++){
str+='*';
}
str+='n';
}
console.log(str);
/* 1 ********** 10
2 *********9
3 ********8
4 *******7
5******6
6*****5
7****4
8***3
9**2
10 *1 *///Algorithme de base : var j=i;j<=10;j++//Idée : analysez d'abord les résultats et observez la relation entre les lignes et les colonnes. Déterminez ensuite l'algorithme de la boucle interne // imprimez un triangle équilatéral, la même idée que ci-dessus.
var str='';
pour (var i=1;i<=9;i++){
pour (var j=1;j<=i;j++){
str+='*';
}
str+='n';
}
console.log(str);//Pour imprimer la table de multiplication, remplacez l'astérisque du triangle équilatéral par l'équation var str = '';
pour (var je = 1; je <= 9; je++) {
pour (var j = 1; j <= i; j++) {
/* str+='*'; */
str += i + '*' + i + '=' + i * j + ' t';
}
str += 'n';
}
console.log(str);//Rappelez-vous : la boucle externe boucle une fois et la boucle interne est exécutée du début à la fin. Elle imprime simplement l'essence du graphique. Le résumé des boucles
while boucle
L'instruction while peut exécuter un morceau de code spécifié dans une boucle en partant du principe que l'expression conditionnelle est vraie, jusqu'à ce que l'expression le fasse. La boucle ne remplit pas les conditions.Structure
syntaxique de l'instruction
while while (expression conditionnelle) {
//Instruction du corps de la boucle ;
}
Idée d'exécution :
exécutez d'abord l'expression conditionnelle, si la condition est vraie, puis exécutez le code du corps de la boucle, sinon, quittez la boucle et exécutez le code suivant
pour exécuter le
code du corps de la boucle. Le code est exécuté, le programme continuera à juger et à exécuter l'expression conditionnelle. Si la condition est toujours vraie, continuez à exécuter le corps de la boucle. L'ensemble du processus du corps de la boucle ne se terminera pas tant que la condition de la boucle ne sera pas fausse
. comme suit
Démonstration de code
var num=1 ; //Initialiser les variables while(num<=10){//Expression conditionnelle console.log('Hello world');
num++;//Operation expression } Remarque :
Il existe également une expression d'opération dans while pour terminer la mise à jour du compteur et éviter une boucle infinie (je n'ai pas ajouté d'expression d'opération, mais lorsque j'ai exécuté le code, l'interface de Google Chrome était noir).
Il devrait également contenir des variables d'initialisation de compteur.
La boucle while peut être équivalente à la boucle for dans une certaine mesure. Il vous suffit de mettre les variables initialisées, les expressions conditionnelles et les expressions d'opération dans la boucle for. .
Démonstration de code
//Imprimer la vie d'une personne, de 1 an à 120 ans var age = 1;
tandis que (âge <= 120) {
console.log('Cette personne a cette année' + âge + 'ans');
âge++;
}
//2. Calculez la somme de tous les entiers compris entre 1 et 100 var sum = 0,
je = 1 ;
tandis que (i <= 100) {
somme += je;
je++;
}
console.log(somme);
//3. Ouvrez une boîte de dialogue, m'aimez-vous ? Si vous entrez Je t'aime, cela affichera la fin, sinon il continuera à demander var message='M'aimes-tu';
while(message!=='Je t'aime'){
message=prompt('M'aimes-tu ?');
}
alert('Je t'aime aussi'); boucle do...while l'
instruction do...while est en fait une variante de l'instruction while. Cette boucle exécutera d'abord le bloc de code une fois, puis jugera l'expression conditionnelle si la condition. est vrai, le corps de la boucle sera exécuté à plusieurs reprises, sinon il quittera la boucle
do... La structure syntaxique de l'instruction while est la suivante
do {
//Code du corps de la boucle - Répétez le code du corps de la boucle lorsque l'expression conditionnelle est vraie
}
Idée d'exécution :
exécutez le code du corps de la boucle une fois
, puis exécutez l'expression conditionnelle si le résultat est vrai, continuez à exécuter le code du corps de la boucle si c'est le cas. est faux, puis quittez la boucle et continuez à exécuter le code suivant.
Remarque : exécutez d'abord l'instruction du corps de la boucle, puis jugez. Nous constaterons que l'instruction de la boucle do...while exécutera le corps de la boucle au moins une fois.
contrôle de processus
Démonstration de code
//Imprimer la vie d'une personne, de 1 à 120 ans var age = 1;
faire {
console.log('Cette personne a cette année' + âge + 'ans');
âge++;
} while (âge <= 120 );
//2. Calculez la somme de tous les entiers compris entre 1 et 100 var sum = 0,
je = 1 ;
faire {
somme += je;
je++;
} tandis que (je <= 100)
console.log(somme);
//3. Ouvrez une boîte de dialogue, est-ce que tu m'aimes ? Si vous entrez Je t'aime, cela affichera la fin, sinon il continuera à demander var message = 'Do you love me';
faire {
message = prompt('M'aimes-tu ?');
} while (message !== 'Je t'aime');
alert('Je t'aime aussi'); Résumé des boucles
:la suite est Le mot est utilisé pour sortir immédiatement de cette boucle et continuer. boucle suivante (le code après continuer dans le corps de cette boucle sera exécuté une fois de moins).
Par exemple : si vous mangez 5 petits pains et qu'il y a des bugs dans le troisième petit pain, jetez le troisième petit pain et continuez à manger les quatrième et cinquième petits pains.
Démonstration de code
pour (var i = 1 ; i <= 5 ; i++) {.
si (je == 3) {
continuer;
}
console.log('J'ai mangé le ' + i + 'ème petit pain');
}
Résultat : //J'ai mangé le 1er petit pain //J'ai mangé le 2ème petit pain //J'ai mangé le 4ème petit pain //J'ai mangé le 5ème petit pain mot-clé break
Le mot-clé break permet de sortir immédiatement de toute la boucle (Fin de cycle)
Par exemple : après avoir mangé cinq petits pains, j'ai trouvé un ver sur le troisième et j'ai perdu l'appétit.
Exemple de code
pour (var i = 1; i <= 5; i++) {
si (je == 3) {
casser;
}
console.log('J'ai mangé le ' + i + 'ème petit pain');
}
Résultat ; //J'ai mangé le 1er petit pain cuit à la vapeur //J'ai mangé le 2ème petit pain cuit à la vapeur identifiant grammatical convention de dénomination
des variables, le nom de la fonction doit être significatif, le nom de la variable est généralement un nom, le nom de la fonction est généralementun commentaire sur une seule ligne
pour (var i = 1; i <= 5; i++) {
si (je == 3) {
continue; //Veuillez noter qu'il y a un espace avant le commentaire sur une seule ligne }
console.log('J'ai mangé le ' + i + 'ème petit pain');
} Spécification de l'opérateur
//Réservez un espace sur les côtés gauche et droit de l'opérateur pour (var i = 1; i <= 5; i++) {
si (je == 3) {
casser;
}
console.log('J'ai mangé le ' + i + 'ème petit pain');
}