1.数据类型（number,boolean,string,null,undefined,symbol,object）
es是动态语言，弱类型语言，虽然先声明了变量，但是变量可以重新赋值任意类型
弱类型，不需要强制类型转换，会隐士转换类型
Nan:not a number转换数字失败
总结：
1。遇到字符串，+号就是拼接字符串，所有非字符串隐士转换为字符串
2。如果没有字符串，加号把其他所有类型都当作字符串处理，非数字类型隐式转换为数字，undefined特殊，因都没有定义值。所以事一个特殊数字Nan
3。如果运算符事逻辑运算符，短路符，返回就是短路时的类型，没有隐士转换
++和--
单目运算符，代表变量自增，自减
i++先用i，用完之后i在自增加1
++i ,i先自增，在使用i
单目运算符优先级高于双目运算符 三元运算符：
条件表达式？真值：假值 逗号操作符
js运行多个表达式写在一起 比较运算符
console.log(300 == '300') //true 宽松比较
console.log(300==='300')//false 严格比较
使用宽松比较时，尽可能确保比较的类型相同，否则会引起隐士转换，隐士转换的规则不好把控
不知道类型是否一致，但是一定要相等，请使用===，！==
instanceof：判断是否指定类型
typeof：返回类型字符串
delete:删除一个对象（an object）或一个对象的属性，或者一个数组中的某个键值
in:如果指定的属性在对象内，则返回true
var a = new String('b')
console.log(a instanceof String) //true
console.log(typeof(a)) //obhect
console.log(String instanceof Object) //true
console.log(typeof(String)) //function
var trees = new Array('rebwood','bay','cedar','ok','maple')
console.log(0 in trees) //数组的索引
console.log('length' in trees) //true ,对象属性返回true
2.生成器表达式
function *inc()
{
let i = 0
let j = 7
while (true){
yield i++
if (!j--) return 100
}
}
gen = inc()
for (i=0;i<10;i++)
{
console.log(gen.next())
}
/*
{ value: 0, done: false }
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: 4, done: false }
{ value: 5, done: false }
{ value: 6, done: false }
{ value: 7, done: false }
{ value: 100, done: true }
{ value: undefined, done: true }
每次调用next()方法返回一个对象，这个对象包括2个属性value和done
values属性标识yield的返回值，done表示bool类型，done事false表示还有yield要执行
如果执行完或者return后done变成true
*/
3.控制语句
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) //4 上层变量对下层可见
console.log(e) //
console.log(f) //
g = 10
var h = 11
}
}
// console.log(a) //不可见
// console.log(b) //不可见
// console.log(c) //不可见
// console.log(d) //不可见
console.log(e) //var可见
console.log(f) //隐士声明，可见
console.log(g)
console.log(h)
流程控制
if (cond1){
pass
}
else if (cond2){
pass
}
else{
}
/*
条件的false等效
false，undefined,null ,0,Nan '',空数组，空对象
*/
switch (expression){
case label_1:
statements_1
[break]
case label_2:
statement_2
[break]
default:
statements_def
[break]
}
/*
break可选，引出穿透问题，一定要在适当的case中使用break，否则匹配case后
会继续向下执行
*/
for(let i=0;i<10;i++){
console.log(i)
}
for (var x=0,y=9;x<10;x++,y--){
console.log(x*y)
}
for (let i=0;i<10;i+=3){
console.log(i)
}
let x = 10
while (x--){
console.log(x)
}
//条件满足，进入循环，条件为真继续循环 do{
console.log(x)
}while(x++<10)
//先进入循环，然后判断，为真就继续循环
for,,,,in循环
let arr = new Array(10,20,30,40)
for (let x in arr){
console.log(x) //返回索引
}
for (let index in arr){
console.log(`${index}:${arr[index]}`) //插入值返回value
}
let obj = {
a:1,
b:'python',
c:true
}
// console.log(obj.c)
// console.log(obj['a'])
for (let x in obj){
console.log(x) //return key
}
for (let key in obj)
{
console.log(`${key}:${obj[key]}`)//return key:valye
}
let arr = [1,2,3,4,5]
let obj = {
a:1,
b:'python',
c:true
} for (let x of arr){
console.log(x)
} for (let key of obj){
console.log(key) //异常不可以迭代字典
}