块级作用域与嵌套、let、暂行性死区

暂时性死区： 作用域开始 到用let定义变量这段区间内为暂时性死区。let 不会变量提升

let

1. 不会变量提升。

1. 在同一个作用域下不可以重复声明 会出现引用错误

   
   

2. 只能在当前作用域下生效 出现ReferrenceError

let 和 const 的区别
总结

//  let 在同一个作用域下不可重复声明
//  let 不会提升
//  let 只能在当前作用域下生效
// demo1
{
    let a = 1;
}
console.log(a) // 报错 a.is not defined
// demo2
if(1){
    let a = 1;
}
console.log(a) // 报错 a.is not defined
// demo3
for(;1;){
    let a = 1;
}
console.log(a)// 不报错 但是死循环了、
// demo4
for(let i = 0; i < 10; i++){
}
console.log(i)// 报错 i.is not defined
// demo5
var arr = [];
for(var i = 0;i< 10; i++){
    arr[i] =  function(){
        console.log(i);
    }
}
for(var i=0;i<arr.length;i++){
    arr[i]();//0-9
}
// demo6
for (var i = 0; i < 5; i++) {
    i = 'a';
    console.log(i);
}
// demo7
// 好像可以拿到i的值
for (let i = 0; i < 5; i++) {
    i = 'a';
    console.log(i);
}
// demo8
for (let i = 0; i < 5; i++) {
    var i = 'a';// i has already been declared
    console.log(i);
}
// demo9
for(let i = 0;i< 10; i++){
    let i = 0;// i has already been declared
    console.log(i);
}
if(1){
    let a = 1;
    {
        let a = 2;
    }
}
// let 本质就是为了js添加一个块级作用域
// 
// 
// 
// 
// 结构结构赋值
// 
let = [ a ]= [1];
let {(a: b)} = {}; // 报错 Uncaught SyntaxError: Unexpected token '('
let {(a):b} = {};  // 报错 Uncaught SyntaxError: Unexpected token '('
let (a:(b))= {}; // 报错 Uncaught SyntaxError: Unexpected token '('
// 用 let/var 声明加括号就报错。
function foo([z]){
    return z;
}
console.log(foo([1]))
let arr = [1,2,3];
let {0:first,[arr.length-1]:last} = arr;
// 数组也是特殊的对象 也能进行解构赋值
// [(b)] = [3] // 3
// ([b]) = [3] // 报错
({a:(b) = {}}); // b = {} 本身并未匹配 {a:b={}};默认值
// var a= {};
// [(a.b)] = [3]; // a.b = 3;
// console.log(b) // b is not defined
// 
// 
// let a = 'x',b = 'y',obj = {};
// ({a: obj[a + b]} = {a: 2});
// console.log(obj) //{xy:2};
// 
// 
// 
// let obj={a: 1,b: 2,c: 3},obj2={} ;
// ({a: obj2.x,b:obj2.y,c:obj2.z})
// 
// 
// 值交换
// let a =10,b=20;
// [b,a] = [a,b];
// 
// 
// 变量的解构 就是变量的赋值，变量通过模式匹配来解构赋值。
// 
// 
// let {a:x,a:y} = {a:1};
// console.log(x,y);//1 1
// 
// 
var x = 200,y = 300, z = 100;
var obj1 = {x: {y: 42},z: {y: z}};
({y:x = {y:y}}={obj1})
({z:y = {y:z}}={obj1})
({x:z = {y:x}}={obj1})
解构中使用对象或者数组的时候慎用 代码可读性很差
function test([x,y]){
    console.log(x,y);
}
// test(1,2) //1,2
// test([1]) //1
// test() //报错
function foo({x,y}){
    console.log(x,y);
}
foo({x:1,y:1});
function foo({x = 10} = {},{y} = {y:10}){
    console.log(x,y);
}
// foo() 10,10
// foo({},{}) 10 undefined
// foo({x:2},{y:3}) 2,3
// {X:X=3}==>{X=3};
// 解构的隐式类型转换
// 字符串->数组
const [a,b,c,d,e] = "hello";
// 'hello' => 数组 
// 字符串->类数组
let {length:len} = "hello";
// number->包装类
let {toString:s} = 123;
// console.log(s === Number.prototype.toString) true
// 布尔值,number,string 都能进行隐式类型转换。转换成相对应的包装类
// 
// 
// undefined ,null 不能进行隐式类型转换
let {prop} = undefined;
/***************************************************/
// 形参有默认值的时候 形参和实参的映射关系就不存在了。
function foo ({x,y=5} = {}) {
}
// foo({}) undefined 5
// foo({x:1}) 1,5
// foo() undefined 5
// fetch(url, options)
// body:body= "";
function fetch(url,{body = "",methods="get",header={}}={}){
    console.log(method)
}