ES6

• ES5:
  • ’ use strict ’ 严格模式
  • 新增的方法
    • indexOf(字符串,开始位置) 返回指定字符串的固定位置
    • forEach(回调函数) 遍历数组的,返回key和value
    • map(回调函数) 返回新的数组
    • filter(回调函数),当结果为true时返回

改变this指向：
bind();
参数：1.第一个参数就是用来改变的this的新指向
2.后面无数个参数：会被传入改变了this指向的新函数

//例子1：
	var obj = {
	  name :"admin",
	  show:function(){
	    console.log(this.name)
	  }
	}
	var obj2 = {
	  name:"张三",
	}
	obj.show();   //admin
	obj.show.bind(obj2)();    //张三
	
	var a = {
	  name:"root",
	  show:function(){
	    setTimeout(() => {
	      console.log(this)
	    }, 1000);
	  }
	}
	//任何回调函数这的this都指向window
	//若要返回a，则只需要在setTimeout后面绑定setTimeout(() => {console.log(this)}.bind(a), 1000);
	// 或setTimeout(() => {console.log(this)}.bind(this), 1000);
	a.show();     //1秒后返回window

//例子2：
	//传入一个参数时
		function fn (a){
		  console.log(this);
		  console.log(a);
		  // console.log(arguments);
		}
		fn();   //window    undefined
		fn("world");    //window    world   
		fn.bind("hello")();   //hello   undefined
		fn.bind("hello")("world");   //hello  world
		fn.bind("hello","abc","def")("world");   //hello   abc 这是因为abc把def和world挤到后面去了
		
	//传入两个参数时
		function fn2 (a,b){
		  console.log(this);
		  console.log(a,b);
		}
		fn2();    //window   undefined
		fn2("world");  //world  undefined
		fn2.bind("hello")();   //hello undefined   undefined
		fn2.bind("hello")("world");  //hello   world  undefined
		fn2.bind("hello","abc","def","ghi")("world");   //hello  adc   def

JSON
JSON.parse( str ); 将json字符串转换成json对象
JSON.stringify( str ); 将json对象转换成json字符串

	var str = '{"a" :"1","b":"2"}'
	var obj = JSON.parse(str);
	console.log(obj);		//{a: "1", b: "2"}
	
	var str2 = {"a" :"1","b":"2"};
	var obj2 = JSON.stringify(obj);
	console.log(obj2)		//{"a":"1","b":"2"}

	for(var i in str2){
		console.log(i);		//a,b
		console.log(str2[i]);		//1,2	
	}

ES6

let / const,字符串的方法

• let声明变量
• const声明常量(声明后不能修改—>变量指向的内存地址不得改动，其它特性和let一样，)
• 字符串相关
  • str. repeat(n) 方法字符串复制指定次数。n为指定重复的次数
  • includes(str,start) 判断字符串中,是否包含某个字符(记住)
  • startsWith(str为指定的字符串,start为开始的位置) 字符串是否以某个字符开头
  • endsWith(str,start) 字符串是否以某个字符结束

	var str = "hello world";
	console.log(str.repeat(3));		//hello worldhello worldhello world
	
	console.log(str.includes("o",8));		//false,空格也有对应的下标
	console.log(str.includes("w",4));		//true
	console.log(str.includes("a",0));		//false
	console.log(str.includes("hello"));		//true
	
	console.log(str.startsWith("h",0));		//true
	console.log(str.startsWith("w",6));		//true
	console.log(str.startsWith("a",0));		//false
	console.log(str.startsWith("world",6));		//true
	
	console.log(str.endsWith("o",5));		//true
	console.log(str.endsWith("w",4));		//false

遍历字符串for-of

	var str2 = 'abcd';
	for (let i of str2){
		console.log(i);		//a,b,c,d
	}

let与var的区别:
1.let不存在变量提升
2.暂时性死区
3.不允许重复声明，同一作用域内只能声明一次
4.新增的块级作用域 -----> for(作用域A){作用域B} 循环的应用；

字符串拼接

用 ${变量名 } 括住变量实现拼接;

	var a = "我想";
	var b = "拼成";
	var c = {
		txt:'一句话'
	};
	var str = `${a}${b}${c.txt}`;
	console.log(str);		//我想拼成一句话
	
	//可以换行
	console.log(`${a}
	${b}
	${c.txt}`)
	
	//可以用来调用
	function fn(){
		return "hello world";
	}
	console.log(`你好${fn()}`);		//你好hello world

箭头函数

老方法：var fn = function(n){return x+1;}
箭头函数：
(参数1, 参数2, …, 参数N) => { 函数声明 }
(参数1, 参数2, …, 参数N) => 表达式（单一）
//相当于：(参数1, 参数2, …, 参数N) =>{ return 表达式; }

// 当只有一个参数时，圆括号是可选的：
(单一参数) => {函数声明}
单一参数 => {函数声明}

// 没有参数的函数应该写成一对圆括号。
() => {函数声明}

注: 如果不加{},则默认使用return

//箭头函数，省略了function、return关键字和大括号
	var fn = (n)=>n+2;

//没参数的箭头函数要在箭头前加上小括号
	var fn1 = ()=>{console.log("箭头函数")}

//有参数的箭头函数
	var fn = (n) =>{
		console.log(n+2);
		}
	fn(2);


//多个参数
	var fn = (a,b,c,d) => a+b+c+d;
	console.log(fn(1,2,3,4))


//{}里面要用return
	var fn = (a,b,c,d) =>{
		return a+b+c+d;
	}
	console.log(fn(1,2,3,4))

箭头函数中的this
一般情况下：this在哪个对象中,就代表那个对象.如果没有直接的对象就直接指向window
箭头函数中：箭头函数自动绑定外层函数的this。当多个箭头函数嵌套时，它们会逐层向上寻找里它最近的函数，若没找到，则this指向全局，即window

//一般情况下，向上寻找，因为上面没有找到对象，所以就指向window
var obj = {
  name:"Lily",
  show:function(){
    console.log(this)
  }
}
obj.show();   //window

//箭头函数中，离它最近的函数是show，但show又在obj2中，所以指向obj2
var obj2 = {
  name:"Lily",
  show:()=>{
    console.log(this)
  }
}
obj2.show();   //obj2

解构赋值

作用：可以将值从数组或属性从对象提取到不同的变量中

//数组的解构：按照索引顺序，从左向右，一一对应
	var arr = ["hello",123,[1,2,3],function(){console.log("world")},true,{name:"admin"}]			
	var [a,b,c,d] = arr;
	console.log(a,b,c,d);		//hello 123 (3) [1, 2, 3] ƒ (){console.log("world")}
	console.log(b,c,d,a);		//123 (3) [1, 2, 3] ƒ (){console.log("world")} "hello"

	// var [b,c,d,a] = arr;
	// console.log(b,c,d,a);		hello 123 (3) [1, 2, 3] ƒ (){console.log("world")}


//对象的解构：按照key一一对应
	var obj = {
		name:"admin",
		age:18,
		show:function(){
			console.log(this.name)
		}
	}
	var {name,age,show} = obj;
	console.log(name,age,show);		//admin 18 ƒ (){console.log(this.name)}

	// var {age,name,show} = obj;
	// console.log(name,age,show);		admin 18 ƒ (){console.log(this.name)}

//数组的解构：按照索引顺序，从左向右，一一对应
	var str = "hello world";
	var [a,b,c,d,e,f,g] = str;
	console.log(a,b,c,d,e,f,g);		//h e l l o   w
	console.log(g,f,e,c,a,b,d);		//w   o l h e l
	
	// var [g,f,e,c,a,b,d] = str;
	// console.log(a,b,c,d,e,f,g);		//o   l w l e h

symbol类型

本质上是一种唯一标识符，Symbol函数会生成一个唯一的值可以理解为Symbol类型跟字符串是接近的 但每次生成唯一的值，也就是每次都不相等.

创建方式：

var s1 = Symbol("a");
var s2 = Symbol("a");
console.log(typeof s1);		//symbol
console.log(s1 == s2);		//false

写法(Symbol 值作为对象属性名时，不能用点运算符)：

let mySymbol = Symbol();

// 第一种写法
let a = {};
a[mySymbol] = 'hello';

// 第二种写法
let a = {
  [mySymbol]: 'hello'
};

唯一值：

var num = {
	a:Symbol("one"),
	b:Symbol("one"),
	c:Symbol("one")
}

function fn(abc){
	switch(abc){
		case num.a:
			console.log("第一个");
			break;
		case num.b:
			console.log("第二个");
			break;		
		case num.c:
			console.log("第三个");
			break;
	}
}

fn(num.b);		//第二个

set / map

1.Set对象不是数组， 可以用来保存对象或者基本类型， 所有保存的值都是唯一的,本质上就是对数组的一种包装

• 默认去重，没有下标
• 属性：setObj.size（返回Set对象的值的个数）
• 方法：
  • setObj.add(value)
    • 在Set对象尾部添加一个元素。返回该Set对象。
  • setObj.clear()
    • 移除Set对象内的所有元素。
  • setObj.delete(value)
    • 移除Set的中与这个值相等的元素
  • setObj.has(value)
    • 返回一个布尔值，表示该值在Set中存在与否。
  • setObj.forEach(callbackFn[, thisArg])
    • 按照插入顺序，为Set对象中的每一个值调用一次callBackFn。
• 遍历：for-of，forEach()

set默认是去重的：

let arr =new Set([1,"1",2,3,2,"5","5"])	
//去重的前提条件是它们是否严格相等
	console.log(arr);		//{1, "1", 2, 3, "5"}
	console.log(typeof arr);		//object

//setObj.size,返回Set对象值的个数	
	console.log(arr.size);		//5

//尾部添加一个元素
	arr.add("我是新增的");
	arr.add("我是最后一个");
	console.log(arr);		//{1, "1", 2, 3, "5","我是新增的","我是最后一个"}

//set没有下标,遍历可以使用for-of、forEach()
	console.log(arr[1]);		//undefined
	console.log(arr[3]);		//undefined
	
	for(let i of arr){
		console.log(i);		//1, "1", 2, 3, "5","我是新增的","我是最后一个"
	}
	
	arr.forEach(function(j){
		console.log(j);		//1, "1", 2, 3, "5","我是新增的","我是最后一个"
	})

2.map

• mapObj.set(“key”,“value”)，尾部添加一个元素
• mapObj.get(“key”)获取值
• mapObj.size，计算长度
• 遍历：for-of

var obj = new Map();
//值的存储
obj.set("name","admin");
obj.set("age",18);
console.log(obj);		//{"name" => "admin", "age" => 18}
console.log(typeof obj);	//object

//获取值
console.log(obj.get("name"));		//admin

//计算长度
console.log(obj.size);	//2

//遍历for-of
for(let i of obj){
	console.log(i);		//["name", "admin"] ["age", 18]
	console.log(i[0]);		//name,age
}

set和map的区别：
set结构类似于数组，但不允许重复，map的结构是键值对集合

class

class用于声明一个类，类自身指向的就是构造函数

原来构造函数的写法：

function fn(){
	this.name = "root";
}
fn.prototype.init = function(){
	console.log(this.name);		//root
}
var obj = new fn();
console.log(obj);		//{name: "root"}
obj.init();


function Person(name,age){
	this.name = name;
	this.age = age;
}
Person.prototype.say = function(){

}
var obj = new Person("root",18);
console.log(obj.name);		//root

class类的写法

class fn{
	constructor(){
		this.name = "admin";
	}
	init(){
		console.log(this.name);		//admin
	};
	display(){

	};
	info(){

	}
}
var obj = new fn();
console.log(obj);		//fn {name: "admin"}
obj.init();


//class定义一个类
class Person{
	constructor(name,age){
		//this代表实例对象
		this.name = name;
		this.age = age;
	}
	say(){	//类的方法,毁自动绑定到构造函数的原型上
		// return "my name is " + this.name + " i am " + this.age + " years old"
		return `我是${this.name}，我今年${this.age}岁了`
	}
}
//类的实例化
var obj = new Person("admin",20);
console.log(obj.say());
//指向构造函数
console.log(Person === Person.prototype.constructor);  //true

类的继承—extends

class Humen{
	constructor(name,age){
		this.name = name;
		this.age = age;
	}
	say(){
		return `我是${this.name}，我今年${this.age}岁了`
	}
}
var obj = new Humen("admin",18);
console.log(obj.say());		//我是admin，我今年18岁了


//extends继承
class Person extends Humen{
	like(){
		return "我继承了属性，现在" + this.name+"名字"+"年龄" + this.age 

	}
}
var pobj = new Person("root",20);

console.log(pobj.like());	//我继承了属性，现在root名字年龄20
console.log(pobj.say());	//我是root，我今年20岁了