EX6 笔记 1

第一天


1.let 命令


  作用：声明变量，只在let命令所在的代码块内部有效

列：{
var a=100;
let b=200; 作用效果只限于 代码块之内
}
console.log(a);//100
console.log(b);//b is not defied --Error



   let 不存在变量提升

ES5写法：
console.log("es5:");
var a=[];
for(var i=0;i<10;i++){
var c=i;
a[i]=function(){
console.log(c); // c在不断的变化
}
}
a[5]();//调用a方法输出来的是9

ES6写法：
var b=[];
for(var i=0;i<10;i++){
let d=i;
b[i]=function(){
console.log(c); // let只在代码块内部中有效 
}
}
b[5]();//调用a方法输出来的是5

let 暂时性死取
     只要块级作用于内存内存在let命令，它所声明的变量就绑定 在这个区域，不在受外部影响
 var a=300;
 {
console.log(a);//undefined  不在定义之前 输出a为暂时性 死区 ，
let a=200; 
console.log(a);// let 不受外部影响 输出 200
 }
 
let 不允许重复声明
只要在同一个模块中，就不能重复声明
{
var a=100；
var a=200；
}
console.log(a);//输出200
{
var a=100;
let a=200;
}
console.log(a);//输出有问题  let 不能重复声明
{
let a=100;
var a=200;
}
console.log(a);//输出有问题  let 不能重复声明
{
let a=100;
let a=200;
}
console.log(a);//输出有问题  let 不能重复声明


在模块内部

{
var a=100；
var a=200；
console.log(a);//输出200
}

{
var a=100;
let a=200;
console.log(a);//输出有问题  let 不能重复声明
}

{
let a=100;
var a=200;
console.log(a);//输出有问题  let 不能重复声明
}

{
let a=100;
let a=200;
console.log(a);//输出有问题  let 不能重复声明
}


模块和模块之间 是可以的 
{
var a=100；
var a=200；
}
{
let a=200;
}
console.log(a);//输出有问题  let 不能重复声明

块级作用域 
由来：第一种场景，内层变量可能会覆盖外层变量。 第二种场景：用来计数的循环变量泄露为全局变量.
场景1:
 var time=new Date();
 function fun(){
console.log(time);
if(false){
var time="Hello World!";
}
 };
 fun();
 
 //结果 输出undefined
 理论 输出 new Date();
变量提前（http://www.bootcss.com/article/variable-and-function-hoisting-in-javascript/）参考地址

场景2:
var string="Hello World!";
 
for(var i=0;i<string.length;i++){
console.log(string[i]);
}
console.log("循环结束");
console.log(i); //输出12 说明i 还存在
 
 
 
let 实际上为JavaScript新增块级作用域
console.log("ES5:);
function fun(){

var  num=100
if(true){
var num=200;
}；
console.log(num); //输出200

};
 
 
console.log("ES6:);
function fun(){

let num=100
if(true){
let num=200;
}；
console.log(num);//输出100 内部代码不会影响内部 代码块

};

 立即执行函数(函数的自调用)
console.log("ES5:);

function fun(){
console.log("i am outside");
};



(function(){
if(false){
funciton fun(){ //由于函数的提前 会覆盖第一次定义的函数
console.log("i an inside!");
};
};
fun();//调用内部的 fun函数
})



console.log("ES6");

function fun(){
console.log("i am outside");
};



(function(){
if(false){
funciton fun(){  //由于块级作用域， 内部函数只在 if 的{} 大括号中起作用
console.log("i an inside!");
};
};
fun();//调用外部的 fun函数 
})



const


 const 定义 常量 ,有块级作用域，暂时性死区，不可从复声明

const PI=3.1415926535
console.log(PI);

 const对象
const person={};//变量对象指向 一个对象 也就是一个地址
person.name="zhangsan";
person.age=30;
console.log(person.name);//Zhangsan
console.log(person.age);// 30
console.log(person);{name:"zhangsan",age:30}

person={} //报错//person is read-only  如果这样写，上面的代码也会报错


 const 数组

const arr=[];
arr.push("Hello world!");
console.log(arr);
console.log(arr.length);
console.log("------");
arr.push("Hello world!");
console.log(arr);
console.log(arr.length);
console.log("------")
arr.lenght=0;
console.log(arr);
console.log(arr.length);
console.log("------")

 const 冻结
  
  列1：
 const person=Object.freeze({

 
 });//冻结对象的声明
 person.name="zhangsan";
 person.age=30;
 console.log(person.name);//undefined
 console.log(person.age);// undefined
 console.log(person);//object
 
 
 
  列2：
 const person=Object.freeze({
 
person.name:"zhangsan";
person.age:30;
 
 });//冻结对象的声明


 console.log(person.name);//"Zhangsan
 console.log(person.age);// 30
 console.log(person);//object
 
 
 //最后写的函数
 var constantize=(obj)=>{

Object.freeze(obj);
Object.keys(obj).forEach((key,value)=>{
if(typeof obj[key]==='object'){

constantize(obj[key]);

};

})
 
 }



跨模块常量
 //module1.js
 export const intiantName=100;
 export const FloatiantName=3.1415926;
 export const chariantName="variantValue";
 //user.js
 import * as varant from './module';全部用的引用
 console.log(varant.intiantName);//100
 console.log(varant.FloatiantName);//3.1415926
 console.log(varant.chariantName);//variantValue
 
 // otherUse.js
 import {FloatVariantName,charVariantName} as variant from './module'; //只引用FloatVariantName和charVariantName
 console.log(variant.FloatVariantName);
 console.log(variant.charVariantName);
 
 //OnlyInt.js
 import inVariantName as variant from './module';// 只引用inVariantName
 console.log(variant.intVariantName);//100
 


全局变量属性

var varName="variantValue";
//浏览器环境
console.log(window.varName);// varValue
// Node.js 环境
console.log(global.varName); // varValue
//通用坏境
console.log(this.varName);     // varValue

let letName="letValue";
console.log(window.letName);  //undefined  --  use strict
console.log(this.letName);    //undefined  --  use strict

let letName="letValue";
console.log(window.letName);//
console.log(this.letName);//
 
 
结构赋值

1.数组解构
//ES5
var a=1;
var b=2;
var c=3;
//ES6
var [a,b,c]=[1,2.3];
 
console.log(a); //1 
console.log(b); //2
console.log(c); //3
 
let[foo,[[bar],base]=[1,[[2],3]];
console.log(foo);//1 
console.log(bar);//2
console.log(base);//3


let[,,third]=["first","second,"third"];
console.log(third);

let[one,,three]=["One","Two","Trhee"];
console.log(one);//One
console.log(three);//Trhee

let[head,...tail]=[0,1,2,3,4,5,6,7,8,9];
console.log(head);//0
console.log(tail);//1,2,3,4,5,6,7,8,9

2.数组解构不成功

var[temp]=[];
console.log(temp);//undefined;
var[first,second]=[100];
console.log(first);//100
console.log(second);//undefined

3.不完全解构

等号左边的模式，只匹配一部分的等号右边的数组

let[x,y]=[1,2,3];
console.log(x)//1
console.log(y)//2
let[a,[b],c]=[1,[2,3],4];
console.log(a);//1
console.log(b);//2
console.log(c);//4

4.指定默认值
var[temp="string"]=[];
console.log(temp);
var[temp="string"]=["tempString"];
console.log(temp);//"tempString"
 
 
var[temp]=1//报错 is not a funciton at eval
 
 
Set 用法  //只要某种数据结构具有Iterator 接口，都可以采用数组形式的解构赋值

1.set用法
let[a,b,c]=new Set(["a","b","c"]);
console.log(a); //a
console.log(b); //b
console.log(c); //c

function* fibs(){

let a=0;
let b=0;
while(true){

yield a;
[a,b]=[b,a+b];

}

};
var [first,second,third,fourth,fifth,sixth]=fiss();//当满足赋值条件，函数自动结束
console.log(sixth);//5