记录es6(1)

let var

//1、let 的块级作用域
//var 没有块级作用域

function fn1(){
	      for(var i = 0; i < 5; i++){
	          // do something
	      }
	      console.log(i);//5
	  }
	  fn1();

function fn2(){
       for(let i = 0; i < 5; i++){
           // do something
       }
       // console.log(i);//i is not defined
	    }
	    fn2();

//2、var 变量覆盖,原则上变量不能重名

var demo = "小明";
var demo = "小红";
console.log(demo); //小红
		 
let demo1 = 1;
let demo1 = 2; //Identifier 'demo1' has already been declared
console.log(demo1) 

//声明提升 let 不存在声明提前

console.log(name); //空
var name = 123;

// console.log(name1); //Cannot access 'name1' before initialization
let name1 = 123;

//const声明一个只读的常量，一旦声明，常量的值就不能改变
//一般用于定义全局变量
//通常变量名全部大写
//定义后必须赋值
//const 如果定义的是对象、数组、函数、引用数据类型。可以改变其中的存储的数据.

const PI='3.14';
const NUM = {            
name:'Tom',            
age:18,            
sex:"男"        ,
};
NUM.name = "Jary";//修改内部变量
console.log(NUM);       //{name: "Jary", age: 18, sex: "男"}

解构赋值

//解构赋值 从对象和数组中获取特定数据并赋值给变量
//1、对象赋值
//对象字面量的语法形式

 let obj ={
			 val:1,
			 type:2,
			 two:8
		 }
 // 一定要用一对小括号包裹解构赋值语句
		 let {val,type}=obj;
		 console.log(val,type);//1,2
		 let {type,val}=obj;
		 console.log(val,type);//1,2
		 
		 // 使用解构赋值表达式时，如果指定的局部变量名称在对象中不存在，那么这个局部变量会被赋值为undefined
		 let {one,two}=obj;
		 console.log(one,two);//undefined undefined
		 
		 //当指定的属性不存在是，可以随意定义一个默认值，在属性名称后面添加一个等号和相应的默认值即可
		 //当指定的属性存在时，定义的默认值无效
		 let {one=true,two=1}=obj;
		 console.log(one,two);//true 8
		 
		 let {val} = obj;
		 console.log(val);//1
		 
		 // 嵌套对象解构
		 
		 let obj1={
			 tit:{
				 val1:{
					 one:123,
					 two:456
				 }
			 }
		 };
		 let {tit:{val1}}=obj1;
		 
		 console.log(val1.one);//123
		 console.log(val1.two);//456
		 // ... 剩余运算符
		 let obj3 ={
			 a:1,
			 b:2,
			 c:3,
			 d:4
		 }
		 let {a,b,...c}=obj3;
		 console.log(a);//1
		 console.log(b);//2
		 console.log(c);//{c:3,d:4}
		 
		

//数组解构

		 //1
		 let arr = [1,2,3,4];
		 let [v1,v2,v3]=arr;
		 console.log(v1,v2,v3);//1,2,3
		 
		 //2、想拿后面的值前面可以不用定义，用空格代替
		 
		 let [,,v4]=arr;
		 console.log(v4);//3
		 
		 //3、整个赋值
		 
		 let arrall=[...arr];
		 console.log(arrall);//[1,2,3,4]]
		 
		 //4、部分赋值
		 
		 let [a1,b1,...c1]=arr;
		 console.log(a1);//1
		 console.log(b1);//2
		 console.log(c1);//[3,4]
		 
		 // eg: q=1,w=2,让q w交换值
		 // 如果右侧数组解构赋值表达式的值为null或undefined，则会导致程序错误
		 let q=1,w=2;
		 [q,w]=[w,q];
		 console.log(q,w);//2,1 

//字符串解构

const [p, o, i, u, y] = 'hello';
		 console.log(p);//"h"
		 console.log(o);//"e"
		 console.log(i);//"l"
		 console.log(u);//"l"
		 console.log(y);//"o"
		 
		 const {length} = 'hello';
		 console.log(length);//5

模板字符串

//模板字符串${},对ie的兼容性不好 可以替换为''++''

		 let str1= '好好学习，';
		 let str2='天天向上';
		 let str3=`${str1}${str2}`;
		 console.log(str3); //好好学习，天天向上
		 console.log(`你好${str2}`); //你好天天向上

箭头函数

箭头函数本身没有作用域（无this)
//箭头函数的this指向上一层，上下文决定其this
//不让this的指向发生改变

 let fn = a=>a;
		 console.log(fn(1));//1
		 let fa=(a,b)=>{
			 let num = a+b;
			 return num;
		 }
		 console.log(fa(1,2));//3

//适用场景
// 当代码里面需要存this时, let _this=this,

let obja={
			'za':1,
			'zb':function(){
				console.log(this);//指向obja
				console.log(this.za);//1
				setTimeout(()=>{
					console.log(this);//指向obja
					console.log(this.za);//1
					console.log(za);//2
				})
				setTimeout(
				function fb(){
					console.log(this);//指向Window
					console.log(this.za);//undefined
					console.log(za);//2
				}
				)
			}
		}
		let za=2;
		obja.zb()

1. //特点: 箭头函数this为父作用域的this,不是调用时的this
2. // 箭头函数的this永远指向其父作用域,任何方法都改变不了
3. // 普通函数的this指向调用它的那个对象
4. // 箭头函数不能作为构造函数,不能使用new
5. // 箭头函数没有原型属性

// 函数参数的扩展
// 1、默认参数 f为默认参数，如果不传就为5，传值就会覆盖默认值

	function fc(f=5){
			console.log(f);
			return f;
		}
		fc()//5
		fc(6)//6

// 只有在函数没有传参数或者传的参数为undefined时才会使用默认参数,null值是被认为有效的值传递
// // 2、不定参数

function fd(...val){         
			console.log(val);//[1,2,3,4,[1,2,3]]
		}
		fd(1,2,3,4,[1,2,3]);	

Class类

生成实例对象
1、创建构造函数

function Peoson(name,age){
			this.name=name,
			this.age=age
		}

2、 创建实例对象

var p1 = new Peoson('123',2);

3、创建实例方法

Peoson.prototype.prt=function(){
			return this.name+this.age;
		}
		console.log(p1.prt());

Class创建构造函数
1、在类中声明方法不能给方法添加function关键字
2、方法之间不要用逗号分隔
3、类定义不会被提升，必须在访问前对类进行定义

class Persona{
			constructor(name,age){//构造方法
				this.name=name;//this代表实例对象
				this.age=age
			}
			prta(){
				console.log(this.name,this.age)
				return this.name+this.age;
			}
		}
	var p2= new Persona('456',7);
	console.log(p2.prta());

Map Set

// map,映射,即原数组映射成一个新数组
	//通过map可以操作数组中的恶数据
	// var arre=[1,2,3,4]
	var arre=[
		{
			zhi:[
				{
					a:1,
					b:2,
					c:3
				},
				{
					a:4,
					b:5,
					c:6
				}
			],
			d:0
		}
	]
	function maps(arre){
		console.log(arre)
		var arrf=[];
		for(let j=0;j<arre.length;j++){
			for(let i=0;i<arre[j].zhi.length;i++){
				// arrf.map(function(arre[j].zhi[i]){
					arrf.push(arre[j].zhi[i].a)
					arrf.push(arre[j].zhi[i].b)
					if(i==arre[j].zhi.length-1){
						arrf.unshift('一');
						arrf.unshift('二');
					}
				// })
			}
		}
		console.log(arrf);//[2,3,4,5]
	}
	maps(arre);
	
	
	// Map
	//初始化Map需要一个二维数组，
	const map = new Map([
	  ['name', '张三'],
	  ['title', 'Author']
	]);
	//或者初始化一个空map
		
	let myMap=new Map();
	// 创建key值
	myMap.set('onee',123);
	myMap.set('twoe',456);
	myMap.set('threee',789);
	
	myMap.has('onee');
	//判断onee是否存在
    console.log(myMap.has('onee'))//true
	//获取key值
	console.log(myMap.get('onee')); //123
	
	// 因为一个key只能对应一个值,所以重复赋值会被覆盖
	myMap.set('onee','321');
	console.log(myMap.get('onee'))//321
	
	// 删除key值
	myMap.delete('onee');
	console.log(myMap.get('onee')); //undefined
	
	// set和map类似,也是一组key的集合,但他不存储value,在Set中不会存在重复的key.
	let dfg=[1,2,3,4,5,5,6,6];
	var mySet=new Set(dfg);
	mySet.add(1);
	console.log(mySet);//{1,2,3,4,5,6}
	mySet.delete(6);
	console.log(mySet);//{1,2,3,4,5}