ES6学习笔记

let 和 const

let: 声明的变量只有在let命令下的代码块有效，也叫块级作用域

const: 声明的变量是只读的，一旦声明常量的值就不能改变，

但是如果用const来声明数组或者对象，则数组，对象下的值可以改变，原因是const指向的变量的地址没有发生改变

let 和 var的区别

1. let是在代码块内有效，var是全局范围有效
2. let只能声明一次，var可以多次声明；
3. let不存在变量提升，但有作用域链

解构赋值

从数组和对象中提取值，对变量进行赋值，称为解构赋值

1. 基本的数组对数组赋值

let [a,b,c] = [1,2,3];//a=1,b=2,c=3

let [a,...b] = [1,2,3];//a=1,b=[2,3]

let [a,b,c,d,e] = 'hello';//hello

let {foo, bar} = { foo: 'aaa',bar: 'bbb'};
console.log(foo);//aaa
console.log(bar);//bbb

let { baz : foo} = {baz : 'ddd'}
console.log(foo);//ddd
console。log(baz);undefind

var a = 1;
var b = 2;
[a,b] = [b,a];

function fn() {
	return [1,2,3];
}
var [a,b,c] = fn();

var data = {
    name : 'ljc',
    age : 20
}
var {name,age} = data;
console.log(name + age);//ljc20

var ljc=[1,2,3];
var [,x,]=ljc;
console.log(x);//2

var obj = {x : 1,y : 2, z : 3};
var {y : a} = obj;
console.log(a);//2

console.log(`hello world`);	

let str = `<ul>
        <li>1</li>
        <li>2</li>
        <li>3</li>
        <li>4</li>
        <li>5</li>
	 </ul>`;

let lovest = 'ljc';
let out = `${lovest}最帅`;
console.log(out);//ljc最帅

function fn () {
        console.log('我是ljc');
    }
let out = `${fn()}`;//我是ljc

const name = 'ljc';
const age = 20;
const my = {
    name,
    age,
    say() {
        console.log('我是' + name + '今年' + age);
    }
}
my.say()//我是ljc，今年20

//ES6
let res = () => {
    let a = 3;
    console.log(a);
}
//ES5
var rel = function() {
    var b = 2;
    console.log(b);
}
res();//3
rel();//2

let say = () => {
    console.log('ljc');
}
say();//ljc

let test = a => {
    console.log(a);
}
test('我是ljc');//我是ljc

let test = (a,b) => {
    console.log(a + b);
}
test(2,3);

let say = () => console.log('ljc');
say();//ljc

function date(...args) {
    console.log(args);
}
date('l','j','c');//['l','j','c']

function add(x,y) {
	return x + y;
}
let num = [1, 2];
add(...num)//3

function push(array, ...rest) {  
    array.push(...rest);//这个是扩展运算符，将...rest转化成参数列表  
}
let arr =[1,2];
push(arr,3,4,5);
console.log(arr);//[1,2,3,4,5]

let s1 = Symbol();
let s2 = Symbol();
console.log(typeof s1);// symbol
console.log(s1 === s2); // false

let s4 = Symbol.for('ljc');
let s5 = symbol.for('ljc');
console.log(s4 === s5);//true

let mySymbol = Symbol();
var a = {};
a[mySymbol] = 'Hello!';
console.log(a);//{ symbol(): 'Hello!' }

var obj = {}
var a = Symbol('a')
var b = Symbol('b')
obj[a] = 'a'
obj[b] = 'b'
Object.getOwnPropertySymbols(obj)
//[Symbol(a), Symbol(b)]

var a = Symbol('a'); 
var b = Symbol('b'); 
var obj = {
    foo: