Quelles structures d'instructions javascript possède-t-il ?

Javascript a trois structures d'instructions : 1. Structure séquentielle ; exécution descendante, ligne par ligne. 2. Sélectionnez une structure de branche ; il existe plusieurs chemins et, selon différentes conditions, n'en exécutez qu'un ou exécutez sélectivement plusieurs chemins. 3. Structure en boucle ; exécutez certains codes à plusieurs reprises.

L'environnement d'exploitation de ce tutoriel : système Windows 7, JavaScript version 1.8.5, ordinateur Dell G3.

Trois structures majeures du langage JavaScript

• Structure séquentielle

  De haut en bas, exécutée ligne par ligne, premier arrivé, premier servi, la même instruction, cette dernière couvre la précédente

• Choisissez un structure de branche

  Éléments multiples Chemin, selon différentes conditions, n'en exécuter qu'un seul ou en exécuter plusieurs de manière sélective

• Structure de boucle

  Exécuter à plusieurs reprises certains codes pour remplacer certaines opérations répétitives, réduire la redondance du code et améliorer l'efficacité

Sélectionnez la structure de branche

1. Structure à branche unique

Choisissez l'une des deux voies, faites-le ou ne le faites pas, ayez-le ou non, exécutez-le ou ne l'exécutez pas

(1) si ; déclaration de jugement

//语法结构：
if(){}
    if	//语句名
    ()	//是否执行的条件，true 或 false
    {}	//执行的内容
//例：
if(true){
   console.log("hello");//"hello"---if括号中是true则输出hello，若为false则不输出
}

2. Structure à double branche

Il existe deux options, qui doivent toutes deux en exécuter une

(1) déclaration de jugement if-else

//当条件判断为true时，执行花括号内的语句，如果条件为假false，跳过花括号内的语句执行else里的内容
if(条件){        
    执行语句1，条件为真时执行   
}else{        
	执行语句2，条件为假时执行    
}

(2) Cas particuliers dans le if condition

1) Situation conventionnelle

Habituellement, une déclaration de jugement est remplie entre parenthèses if pour juger si elle est vraie ou fausse. Les éléments entre parenthèses if() sont généralement appelés points logiques et points de jugement. Lorsque le contenu entre parenthèses est vrai, il est vrai, et lorsqu'il est faux, il est faux ou faux est une valeur booléenne (booléenne) représentant vrai et faux. Elle doit être obtenue via des opérateurs logiques

. 2) Cas particuliers

Regardons un premier exemple

if(1){ //括号内填写数字"1"会发生什么
    console.log("会输出么？"); //会输出吗？---会在控制台输出内容
}

Le chiffre 1 est une valeur numérique, pas une valeur booléenne, et encore moins vraie. Pourquoi l'instruction entre accolades est-elle exécutée ?

Dans certains cas spécifiques, l'ordinateur effectuera des conversions implicites. Ceci est différent de la conversion de type forcée. Il ne nécessite aucune action de votre part et convertira automatiquement le type de données

Dans les opérations, si (parenthèses) Type implicite. la conversion aura lieu pour les déclarations dans

//if隐式转换例题
var a = "1",b = 2;    
console.log(a + b);//12---+号进行字符串拼接，拼成12，而不是进行数值运算等于3

Le signe "+" a deux significations :

• Il y a des nombres des deux côtés du signe "+" : c'est l'opérateur de signe "+" en mathématiques, combinant deux Ajouter nombres et effectuer des opérations numériques

• Un ou plusieurs caractères apparaissent des deux côtés du signe "+": Il s'agit de l'épissage des chaînes

et la priorité est donnée à l'épissage des chaînes, donc seuls les côtés gauche et droit de le signe + est détecté Lorsqu'une chaîne existe, les données de l'autre côté qui n'est pas une chaîne seront automatiquement converties en chaîne, puis l'opération d'épissage de chaîne sera effectuée (l'épissage de chaîne consiste à joindre le contenu des deux côtés de le signe "+" complètement sans aucune modification. Ensemble)

Remarque : à l'exception du signe +, qui a deux significations, le signe "-*/%" n'a qu'une signification mathématique, donc lorsque "-*/%" est utilisé , les types de données des deux côtés de l'opérateur sont implicitement convertis par défaut en un type numérique, puis effectuez l'opération

Et si vous souhaitez effectuer une opération d'addition mais ne souhaitez pas être implicitement converti en caractère par. le signe "+".

Méthode :

var a = "1",b = 2;    
console.log(a + b);//12---默认进行字符串拼接输出字符串"12"
console.log((a-0) + b );//3---先通-0操作将字符转换为数字，再进行相加，输出数值3

3) Conversion de type implicite dans if

If() ne nécessite que des valeurs booléennes, alors dans le jugement if, tous les types de données entre parenthèses seront implicitement convertis en type booléen, n'importe quel type le sera éventuellement être converti en type booléen

•                    ' s ' s ' s  ‐ ‐ ‐ ‐ ​ ​ ​ ​ ​ ​​ ​ ​Objet : à tout moment Est vrai

•                                                               ’ NaN : est faux

• Dans Undéfini : Pour Faux

• Null : Pour False

• isnan ():
  déterminer si NAN peut indirectement déterminer si c'est un nombre, en revenant à Vrai, nan n'est pas un nombre, en revenant à faux, c'est le nombre

• 3 Structure multi-branches

• Il y en a au moins deux ou plus, une ou. plus de déclarations sont exécutées selon conditions

  （1)多个if(){}else{}嵌套使用

  if(true){
      console.log("hello");
  }else{
      if(true){
          console.log("hello");
      }else{
          console.log("world");
      }
  }
  或者
  if(true){
      console.log("hello1");
  }else if(true){
      console.log("hello2");
  }else if(true){
      console.log("hello3");
  }else if(true){
      console.log("hello4");
  }

  （2）使用switch(){}语句

  系统提供的语句
  

  switch(){}

  • switch语句名

  • ()要判断的值

  • {}执行语句，所有的分支路径都放在一个花括号内

  • case匹配（）内的值则执行，不匹配则往下找，找到执行，都没找到输出default的内容

  案例：输入数字，判断后输出星期几
  

  switch(n){
      case 1:console.log("星期一");break;
      case 2:console.log("星期二");break;
      case 3:console.log("星期三");break;
      case 4:console.log("星期四");break;
      case 5:console.log("星期五");break;
      case 6:console.log("星期六");break;
      case 7:console.log("星期七");break;
      default:console.log("请输入1-7之间的数字");
  }

  （3）switch的注意事项

  case的穿透特性：

  在一个switch中，只会进行一次case判断，如果判断成功，后面的case则不会判断全部执行
  阻止case穿透
  使用关键字break;可以跳出当前循环，后面的都不执行
  
  switch和if-else的区别

  • switch只能判断具体的值，不能判断范围，不会进行隐式转换

  • if else可以判断范围

  循环结构

  1.while循环

  while(){}
      while	//语句名
      ()		//执行条件、判断调价
      {}		//执行语句循环体
  //例：
  var i = 0；
  while(i<10){//当括号内的条件为真时，会一直执行
      console.log(i);//输出0-9，十个数字
      i++;//改变计数器
  }
  //表示重复执行10次
  //注意：为避免死循环，一定要在循环体内 改变 条件中使用变量的值-改变计数器。
  //通常while被用在不确定执行次数的循环中，循环体内设置if判断，满足条件使用break结束循环，否则一直循环

  2.do-while循环

  do{}while(){}
      do		语句名
      {}		do的执行语句
      while	语句名2
      ()		执行条件
      {}		while的执行语句
      
  do{
      console.log("do的执行语句");
      i++;//改变计数器
  }while(i<10){
      console.log("while的执行语句");
  }
  //条件为true时，会执行do后面的语句
  //条件为false时，会执行一次while后面的语句
  //注意：do-while的改变计数器要鞋子啊do语句中，否则会造成死循环
  do-while和while的区别
      do-while任何情况下都比while多执行一次（do-while无论真假都会执行一次while里的语句）
      do-while相对于while结构紧密些

  3.for循环

  for(){}
      for		语句名
      ()		条件组
      {}		循环体
  for(var i = 0; i < 10; i++){
      console.log(i);//打印0-9。共十个数字
  }
  
  for循环括号内的内容
  var i=0;	//定义循环开始时计数器的初始值
  i<10;		//设置停止循环的条件，满足条件执行循环，不满足条件结束循环
  i++		//计数器加一（这条语句是在循环体内容结束后才执行）
  //注意：上面的三个内容必须用分号“;”隔开，否则报错
  
  for循环是最长使用的循环，还可进行for循环嵌套
  for(var i=0;i<10;i++){
      for(var j=0;j<10;j++){
          console.log(i+j);
      } 
  }

  4.死循环

  无法靠自身控制结束的循环，称为死循环
  不知道要循环几次的问题，利用死循环的原理，每次判断一个条件，直到满足条件，利用break跳出循环
  通常使用while来进行死循环

  5.continue关键字break关键字

  continue和break都是用来控制循环结构的，主要是用来停止循环。   
  控制关键字：控制循环的执行或停止
      break:结束循环语句，直接跳出当前循环语句，后面所有的下一次循环都不执行。
      continue:表示跳过当前所在的本次循环（continue下面的语句不执行跳过），下一次循环还会正常执行

  【推荐学习：javascript高级教程】

  Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!