Node.js语法

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

function hello(){
    let a=1 //只能在函数内用
    var b=2 //只能在函数中用
    c=3 //全局定义
}
if (1){
    let d=4 //定义较严格，只能在块内使用
    var e=5 
    f=6
    if (true){
        console.log(d)
        console.log(e)
        console.log(f)
        console.log('-'.repeat(30))
        g=10
        var h=11
    }
}
hello()

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 (cond1){
}
else if (cond2){
}
else if (cond3){
}
else{
}

条件的False等效
false
undefined
null
0
NaN
空字符串
其它值都将被视为True
swith……case分支语句

switch (expression) {
case label_1:
		statements
		[break;]
case label_2:
 		statements
 		[break]
……
default:
		statements_def
		[break]
}

这里最大的问题，就是穿透问题，一定要在case中恰当的使用break语句，否则就会继续顺序向下执行

let x=5
switch (x){
    case 0:
        console.log('zero')
        break
    case 1:
        console.log('one')    
    case 2:
        console.log('two')
    case 3:
        console.log('three')
        break
    case 5:
    case 4:
        console.log('four')
    default:
        console.log('other')    
}

for 循环

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

for (let i=0;i<10;i++){
    console.log(i)
}
console.log('-'.repeat(30))
for (var x=0,y=9;x<10;x++,y--){
    console.log(x*y)
}
console.log('-'.repeat(30))
for (let i=0;i<10;i+=3){
    console.log(i)
}

while循环和do……while

while (condition)
		statement

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

do 
		statement
while (condition)

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

let x=10
while (x--){
    console.log(x)
}
console.log('-'.repeat(30))
do{
    console.log(x)
}while(x++<10)

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

for (variable in object) {
		statements
}

let arr=[10,20,30,40]
console.log(arr[1])

for (let x in arr){
    console.log(x)
}
console.log('-'.repeat(30))

for (let index in arr){
    console.log(`${index} ${arr[index]}`)
}
console.log('-'.repeat(30))
for (let i=0;i<arr.length;i++)
    console.log(arr[i])

let obj={
    a:1,
    b:'string',
    c:true
}

console.log(obj.a)
console.log(obj['b'])
console.log(obj.d)
console.log('-'.repeat(30))
for (let x in obj){
    console.log(x)
}
for (let k in obj){
    console.log(`${k} ${obj[k]}`)
}

for in 循环返回的是索引或者key，需要间接访问到值
数组返回的是索引
for……of 循环

let arr=[1,2,3,4]
let obj={
    a:1,
    b:'string',
    c:true
}
for (let i of arr){
    console.log(i)
}

for (let i of obj){
    console.log(i)
}

注意：for ……of 不能迭代一个普通对象
原因是，of后面必须是一个迭代器
break、continue
break结束当前循环
continue中断当前循环，直接进入xia一次循环
for迭代的差别

function sum(arr){
    for (let x in arr){
        //遍历index或对象属性
        console.log(x,typeof(x),arr[x])
    }
    for (let x of arr){
        console.log(x,typeof(x))
    }
    for (let x=0;x<arr.length;x++){
        console.log(x,typeof(x),arr[x])
    }
}
sum([3,6,9])

symbols类型

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

let sym1=Symbol()
let sym2=Symbol('key1')
let sym3=Symbol('key1')
console.log(sym2==sym3) //false,symbol值的唯一的

1、作为对象的属性key

let s=Symbol()
let t='abc'
let a={
    [s]:'abc',
    t:'ttt',
    [t]:'000'
}
console.log(a)
console.log(a[s])
a[s]=2000
console.log(a[s])

2、构建常量