es6基础

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8" />
    <title>es6——1</title>
    <script src='JS/jquery-1.11.1.min.js'></script>
    <link rel="stylesheet" href="CSS/bootstrap.min.css" type="text/css"/>

</head>
<script>
window.onload = function(){

//同一个作用域内不能重复定义同一个名称  ps:let的作用域为{}
let a = 1;let a = 2;
let a = 1; a = 2;//可以

//有严格的作用域,变量隶属于当前作用域;let 块级作用域,var 函数作用域{}

function test(){
    if(true){
        var str = '123';
        let str2 = '123';
    }
    console.log(str,str2);
}
test();
//PS:会直接报错(str2 is nod defined),因为let的作用域只属于{}里面,console.log()找不到str2

//let 不存在变量提升,var命令会‘变量提升’(也就是可以再声明前使用,值未underfined)
console.log(str);//打印出underfined
console.log(str2);//报错,str2 is nod defined
var str = '123';
let str2 = '123';

//暂时性死区
//错误示例
var str = '13';
if(true){
    str = '123';
    let str;//在let的作用域里,str还没被定义前就赋值,是错误的
}
//
var x = y,y = 1;
function fn(){
    console.log(x,y);
}
fn();//x=underfined y=1'
let x = y,y = 1;
function fn(){
    console.log(x,y);
}
fn();//报错,y is not defined

//不能重复声明(同意作用域内,重复声明)
//错误1
function fn(){
    var a = 1;
    let a = 1;
}//错误2
function fn(){
    let a = 1;
    let a = 1;
}//错误,仍然重复
function fn(a){
    let a = 1;
}//正确
function fn(a){
    {
        let a = 1;
    }
    
}
//块级作用域的好处
function fn(a){
    if(true){
        let a = '1';
        console.log(a);
    }
   console.log(a);
}
fn(2);//打印出1,2
//发生了变量提升
function fn(a){
    if(true){
        var a = '1';
        console.log(a);
    }
   console.log(a);
}
fn(2);//1,1


//const
//相同:块级作用域,不可重复定义
//不同:const只读,定义好后不能更改。

const a = '123'; //字符串 布尔 数值
//数组
const arr = [];//此时,const申请的常量是指向数组的指针,所以此时的数组是可改的
arr.push('123');
//对象
const obj = {};
obj.name = 'adc';
console.log(obj);
//定义时必须同时初始化
const w;//错误
const w = 1;//正确

}



//解构(变量解构)  es6中的新特性
//变量解构:字符串,数组解构,布尔,对象解构
let x = 1;
let y = 2;
let z = 3;

let x =1,y=2,z=3;
//数组解构的写法,不是数组,是数组模式
//数组模式 =(运算符) 值
//数组解构,一一对应
let [x,y,z] = [1,2,3];
//x=1
let [x,y,z] = [2,1,3];
//x=2
let [x,y,z] = [2,,3];
//x=1,z=3,y=underfined
let arr = ['1','2','3'];
let [a,b,c]=arr;
//a=1;b=2,c=3


//对象
let obj = {
    name:'sonia',
    age:20
}
//原来的取法obj.name,obj.age
let{name,age} =obj;
console.log(name);//sonia

//模式匹配
let [a,,c] = [1,2,3];
//a=1;c=3
let [a,b,c] = [1,2];
//c=underfined
let [a,b,c] = [1,,3];
//b=underfined


//默认值
let [a=1]=['a'];//var a= 1||'a';
//a=a;
let [a=1]=[];
//a=1;
//例外
let [a=1]=[undefined];
//a=1
let [a=1]=[null];
//a=null

//等号后面的中括号里的可是是任何类型
let [a,b,c,d] = [1,[2,3],4,{x:'x'}];
//表达式 惰性求值
function fn(){
    console.log('123');
}
//x的默认值为fn()返回的值
let [x=fn(),y] = [1,2]
//x=1
let [x=fn(),y] = [,2]
//x=123


//对象    name 匹配模式  a 才是变量 
        let {name:a,age:b} = {age:20,name:'abc'};  //a
        let {name,age} = {age:20,name:'abc'};  //name
        let {abc:name,age:age} = {age:20,name:'abc'};   
        //可以这么认为:=前面的大括号里的‘:’后面的是变量,‘:’前面的是和等号后面的对象的key一一对应
//另一种写法
        let aa = {age:20,name:'abc'};
        let {abc:name,age:age} = aa; 


//题目
let [a,b=2]=['a'];
//a=a,b=2
let [a=1,b=a]=[];
//a=1,b=1
let [a=1,b=a]=[5];
//a=5,b=5
let [a=1,b=a]=[5,8];
//a=5,b=8
let [a=b,b=1]=[,8];
//报错,有a的时候,b还没有





</script>

<body>
  
</body>
</html>

 

阅读更多
换一批

没有更多推荐了,返回首页