深度挖掘JS流程控制语言

条件语句 if、switch

if

if(表达式隐式转换后为true){
	执行语句块
 }
        //i=0 赋值会返回等号右边的值
        //i==0 比较，隐式转换后比较i，有可能是0，false，"",这三种值都可以进入
        //i===0 精确比较 只有i是0时 才可以有进入条件

var obj;
if(obj.a){
     console.log("a");
}//显示undefined     因此如果要判断变量是否存在某个属性，要使用熔断，将判断obj是否存在加入
if(obj&&obj.a){}

if else 语句理论报错后不会执行else语句

if(b>3){   console.log("aaa");   }
else{    console.log("bbb");    }
//因为b没有被定义所有会报错

如果报错后还想执行，可以使用

try{
      尝试执行的语句块
}catch(error){
       //如果尝试执行的语句块错误失败，会执行该代码块
       //报错后，不继续执行后面的语句，直接执行catch
}finally{
       //不管上述哪种都会执行该代码块
}

多分支条件判断

a=90;
            if(a>=90 && a<=100){
                console.log("甲等");
            }else if(a>=80){
                console.log("乙等");
            }else if(a>=70){
                console.log("丙等");
            }else if(a>=60){
                console.log("丁等");
            }else{
                console.log("不及格");
            }
            
// 上面的一次判断，条件可以根据上次的省略部分
// 下面的多次判断,条件必须全面

		  if(a>=90 && a<=100){
                console.log("甲等");
            }
            if(a>=80 && a<90){
                console.log("乙等");
            }
            if(a>=70 && a<80){
                console.log("丙等");
            }
            if(a>=60 && a<70){
                console.log("丁等");
            }else{
                console.log("不及格");
            }

• 遇到多分之条件时，触发条件次数多的写在上面，触发条件次数少的写在下面
• 如果语句块仅有一句时，花括号可以省略 如果没有{}，默认仅执行条件语句的第一句

switch

 switch(表达式)
            case 值1:
            break;
            default :
           
// 状态分支  状态机
 switch(表达式){
                case "值1":
                //  当满足表达式的值绝对与值1相等(===)执行这里的语句
                case "值2":
                // 如果值1的语句后面没有使用break,则自动穿越值2,不判断相等,直接执行值2后面的内容
                //  当满足表达式的值绝对与值2相等(===)执行这里的语句
                break;//当使用break,不继续向下穿越跳出该条件语句
                default:
                // 默认如果表达式与以上所有值都不相等时,执行default后面的语句
                // 一般default中不需要写 相等条件和break
      
  var s=90;
//如果switch判断的内容不是相等(确定)情况下，可以使用true作为switch的表达式
//在case中描述条件，用条件为true的执行对应的语句
        switch(true){
            case s>=90 && s<=100: 
            console.log();
            break;
            case s >=80: 
            console.log();
            break;
            case s >=70: 
            console.log();
            break;
            default:
        }
 //颜色变化红黄绿靛蓝紫红循环
 	    var r=255,g=0,b=0;
        var state=0;
        var div1 = document.getElementById("div1");
        setInterval(function(){
            switch(state){
                case 0: 
                    g++; 
                    if(g===255) state=1;
                    break;
                case 1: 
                    r--; 
                    if(r===0) state=2;
                    break;
                case 2: 
                    b++; 
                    if(b===255) state=3;
                    break;
                case 3: 
                    g--;
                    if(g===0) state=4;
                    break;
                case 4: 
                    r++; 
                    if(r===255) state=5;
                    break;
                case 5: 
                    b--;
                    if(b===0) state=0;
                    break;
                
        }
        div1.style.backgroundColor="rgba("+r+","+g+","+b+",1)";
        },16)

 // 当条件在处理时发生冲突,需要考虑使用状态来做为唯一判断标准

循环

while

三要素:
1、初始变量
2、进入循环的条件
3、有不断向循环外变化的表达式
while(表达式) 如果表达式隐式转换为布尔值时是true，则进入循环

求出1的个数
   	 var i=15;
       var n=1;
       while(i=i&(i-1))n++;
       console.log(n);
 
 // 斐波那契数列
       var n=0;
       var m=1;
       var s=n+m;
       var o;
       var str=n+"+"+m;
       while(m<100){
           o=m;
           m=n+m;
           n=o;
           s+=m;
           str+="+"+m;
       }
       console.log(s,str);

//求水仙花数     100-999   135=1*1*1+3*3*3+5*5*5
       var n=100;
       while(n<1000){
           var a1=parseInt(n/100);
           var a2=parseInt(n%100/10);
           var a3=n%10
           if(n===a1*a1*a1+a2*a2*a2+a3*a3*a3) console.log(n);
           n++;
       }

//在table中用循环添加单元格
   	var table1=document.getElementById("table1");
       var row=0;
       var col=0;
       var str="";
       while(row<10){
           str+="<tr>";
           col=0;//每次循环后必须重新归位
           while(col<10){
               str+="<td></td>";
               col++;
           }
           str+="</tr>";
           row++;
       }
    table1.innerHTML=str;

// 给数组中添加30个不同的随机数
   		 var arr=[],a,i=0;
           while(arr.length<30){
               a=parseInt(Math.random()*100);
               var flag=true;
               while(i<arr.length){
                   if(a===arr[i]) flag=false;
                   i++;
               }
               if(flag===true) arr.push(a);

           }
           console.log(arr);

continue和break的区别

• 给循环增加别称,可以通过break 别称;跳出指定的循环
• 如果满足条件,continue后面的语句不继续执行,仍然循环,而break是直接跳出当前循环;
• continue在多个条件中间不进入时使用最为方便;

   var i=0;
       var n;
      
      while(i<10){
           n=0;
           while(n<10){
               n++;
               if(i===5 && n===5) break;
               console.log(i,n);
           }
           i++;
       } 
  

var i=0;
var n;

   while(i<10){
        n=0;
        while(n<10){
            n++;
            if(i===5 && n===5) continue;
            console.log(i,n);
        }
        i++;
    } 

字符串的方法 charCodeAt()获取字符串中指定位置字符的ASCII码
      //a 97 z 122 A65 Z90 0 48 9 57
      //String.fromCharCode()将ASCII码转换为字符
      
	  var i=48;
      while(i<123){
          if(i>57 && i<65 || i>90 && i<97){
              i++;
              continue;
          }
          console.log(String.fromCharCode(i));
          i++;
      }

//求2-100之间的所有质数
 // 57   2-56
        var i=2;
        var n;
        var flag;
        while(i<100){
           n=2;
           flag=true;
           while(n<i){
               if(i%n===0){
                flag=false;
                break;
               }
               n++;
           }
           if(flag) console.log(i);
            i++;
        }

 //广度遍历 深度遍历
      var link={value:1,next:{value:2,next:{value:3,next:null}}}
      while(link){
          console.log(link.value);
          link=link.next;
      }

var tree={value:1,left:{value:2,left:{value:3,left:{value:4,left:null,right:null}},right:null},right:null};
      var arr=["a","b","c","d","e"];
      var o={value:1,a:{value:2,b:{value:3,c:{value:4,d:{value:5,e:{value:6}}}}}}
      var i=0;
      while(o){
          console.log(o.value);
          var key=arr[i];
          o=o[key];
          i++;
      }

do while

• 先执行,后判断条件是否继续循环
• 尽量规定左侧条件,以根据第一次执行语句块完成后判断是否继续循环
• 适合用于循环条件不确定,并且没有初值

		var s;
        do{
            s=parseInt(Math.random()*100);
            console.log(s);
        }while(s<50);
        console.log(s);

for

		var i=0  在循环前仅作1次
        i<10  在循环前判断是否进入循环 ,每次判断
        i++ 在循环语句块执行完成后,下一次循环条件判断之前执行表达式
        for(var i=0;i<10;i++){
     }

	1.	for(var i=10;i;i--){
            console.log(i);
        }
        
	2.	for(var s=0,i=0;i++<100;s+=i,console.log(s));
        console.log(s);
        
    3. var link={value:1,next:{value:2,next:{value:3,next:{value:4,next:null}}}};
       for(;link;link=link.next) console.log(link.value);