javascript流程控制语句

语句块

JS使用大括号构成语句块
ES6之前语句块是没有作用域的,从ES6开始支持,let只能在块作用域中可见

function hello(){
    let a=10        //没有隐式声明提升
    var b=20        // 在函数内,变量被封装在内部,不能看到
    c = 30         // 隐式声明提升为全局变量
}
if (1){
    let d = 40     //let 只能在if的块中看到
    var e =50      // var 可以突破块
    f =60          // 全局变量
    if (true){
        console.log(d)
        console.log(e)
        console.log(f)
        g = 'a'
        var h = 'b'     // var 可以突破块
    }
}
f()
//console.log(a)      
// console.log(b)
console.log(c)   
// console.log(d)
console.log(e)
console.log(f)
console.log(g)
console.log(h)

流程控制

条件分支

if(condtion1){
    
}
else if(condition2){
    
}
else if(condition3){
    
}
else{
    
}

等效false的条件有 false,undefiend,null,0,NaN,空字符串,其它都备受视为True

a = 100;
if( a>1000) {
    console.log(1000);
}
else if (a > 500) {
    console.log(500);
}
else if (a > 100) {
    console.log(100)
}
else if (a > 50) {
    console.log(50)
}
else{
    console.log(a)
}

switch…case分支语句

switch(expression){
    case label_1:
        statements_1
        [break]
    case label_2:
        statements_2
        [break]
    case label_3:
        statements_3
        [break]
    ...
    default:
        statements_def
        [break]
}

a = 200;
switch(2){
    case 1:
        console.log(1000);
        break;
    case 2:
        console.log(500);
        break;                //如果没有break,则继续向下运行,case 3中的100也会打印
    case 3:
        console.log(100);
}
---------------------------
500

• 这里最大的问题，就是穿透问题，一定要在case中恰当的使用break语句，否则就会继续顺序向下执行
• switch…case语句都可以写成多分支结构

for 循环

// C风格for 循环
for ([initia1Expression];[condition];[incrementExpression]){
    statement
}

for(let i=0;i<5;i++){
    console.log(i)
}                          //0,1,2,3,4

for(let i=0;i<10;i++){
    console.log(i)
}                          //0,1,2,3,4

for(var i=0,j=5;i<5;i++){
    console.log(i*j)
}                          //0,5,10,15,20

while 循环和 do…while循环

• 条件满足,进入循环,条件为真,继续循环

while(condition)
    statement

• 先进入循环,然后判断,为真就继续循环

do 
    statement
while(condition)

let x =10
while(x--){
    console.log(x)
}                        // 打印9~0
do{
    console.log(x)
}while(x++<10)          //打印-1~10

for … in 循环

• 对象操作语句for…in用来遍历对象的属性

for(variable in obj){
    statements
}


let arr = [10,20,30,40,50]

for(i in arr){
    console.log(i)
}                      //返回索引

for(i in arr){
    console.log(i,arr[i])
}                     // 返回索引和元素

let obj = {
    a:100,b:true,c:'abcd'
}
console.log(obj.a)       //访问对象的属性
console.log(obj['a'])    //对象的属性当索引访问

for(let x in obj){
    console.log(x)        //返回对象的属性名
}

for(let x in obj){
    console.log(x,obj[x])   //对象的属性当索引访问
}
------------------------------------------
100
100
a
b
c
a 100
b true
c abcd

for in循环:数组返回的是索引,对象返回的是属性(或者说是key),需要间接才能访问到值

for…of循环

let arr = [1,2,3,4,5]
let obj = {a:1,b:true,c:'abcd'}

for (let i of arr){
    console.log(i)          //返回1,2,3,4,5
}
for (let i of obj){         //异常,不可迭代
    console.log(i)
}

for…of 不能迭代一个普通对象,原因是of后面必须是一个迭代器

break,continue

• break,结束当前循环
• continue 终断当前循环,直接进入下一次循环

for 迭代的差别

function sum(arr){
    for (let i in arr) {   //遍历索引
        console.log(i,typeof(i),arr[i],)
    }
    for (let i of arr){   //遍历元素
        console.log(i)
    }
    for (let i=0;i<arr.length;i++){   // 自己定义索引数值遍历
        console.log(i,typeof(i),arr[i])
    }
}
---------------------------------------------
0 string 10
1 string 20
2 string 30
3 string 40
4 string 50
10
20
30
40
50
0 'number' 10
1 'number' 20
2 'number' 30
3 'number' 40
4 'number' 50

Symbols类型

ES6提供Symbol类型，内建原生类型

let sym1=Symbol()
let sym2=Symbol('key')
let sym3=Symbol('key2')
console.log(sym2==sym3) // false,symbol值是唯一的
console.log(Symbol()==Symbol())  // false,symbol,不与任何值相等,与自己也不相等

Symbol方法

• Symbol()不是一个完整的构造函数，因此不能通过new Symbol() 来创建，而是使用Symbol()来创建一个Symbol实例，这个方法有一个可选参数用来描述symbol，该参数是字符串类型。

 let sym1 = Symbol('test');
 let sym2 = Symbol('test');
 typeof sym1;        //symbol
 sym1 == sym2;       //false

上段代码中，sym1和是sym2都是一个独一无二的值，虽然参数相同，却不相等。可以通过 typeof 运算符判断Symbol值的数据类型。