ES6-function

函数的扩展

1. 函数参数的默认值。

function log(x, y = 'World') {
  console.log(x, y);
}

• 1）允许为函数的参数设置默认值，即直接写在参数定义后面
• 2）即当参数值严格等于undefined时，默认值才会生效
• 3）参数默认值不是传值的，而是每次都重新计算默认值表达式的值
• 4）参数默认值与解构赋值的默认值结合使用

2. 函数的length属性

• 等于实参的长度
• 没有默认值，等于形参的长度 ，有默认值 等于默认值的位置

3. 作用域问题

• 形参所在的小括号是一个单独的作用域，遇到变量来 先看自己的作用域下有没有 没有再往上找

4. 扩展运算符

• 可以将数组变成非数组，也可以将非数组变成数组：let ary = [1,2,3] console.log(…ary)
• 将字符转变成数组:let str = “12345” console.log([…str])
• 将类数组变成数组:

function fn3(){
    return [...arguments].sort();
    }
console.log(fn3(3,2,1,4,6))

• 应用：求出最大值,拼接数组

let arr1 = [1,2,3,34,56,78]  //求出最大值
console.log(eval("Math.max("+ arr1 +")"))
console.log(Math.max.apply(null,arr1));
console.log(Math.max(...arr1))

let a1 = [1,2],a2 = [3,4]  //拼接数组
console.log(a1.concat(a2));
console.log([...a1,...a2])

5. 函数name属性

• 函数的name属性，返回该函数的函数名，bind返回的函数，name属性值会加上bound前缀。

let fn4 = function(){
    console.log(this)
}
//bind
let obj = {};
var ff = fn4.bind(obj)
ff();
console.log(ff.name) //bound fn4
//new
let f = new Function ("n","return n");
console.log(f.name)  //anonymous

6. 箭头函数

• 箭头函数没有this指向，它里面的this是谁，看上一级作用域中的this

var f =() =>5 //等同于
var f = function(){return 5}

var sun = (sum1 , sum2 ) => {sun1 + sum2} //等同于
var sun = function(sun1,sun2){return (sun1+sun2)}

• 若箭头函数要返回一个对象，必须在对象外面加上大括号，否则会报错

let getTempItem = id => ({ id: id, name: "Temp" });

对象的扩展

1. 属性简写

function getPoint() {
    const x = 1;
    const y = 10;
    console.log({x, y}) ; //{x: 1, y: 10}
}
getPoint()

2. 属性遍历

• for…in

var obj = {a:1, b:2, c:3};  
for (var prop in obj) {
console.log("obj." + prop + " = " + obj[prop]);
}

• Object.keys(obj) 返回一个所有元素为字符串的数组

var arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']
var anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.keys(anObj)); // console: ['2', '7', '100']

• Object.getOwnPropertyNames()

 var arr = ["a", "b", "c"];
console.log(Object.getOwnPropertyNames(arr).sort()); // ["0", "1", "2", "length"]

3. super属性

• super，指向当前对象的原型对象。

const proto = {
foo: 'hello'
};
const obj1 = {
foo: 'world',
find() {
    return super.foo;
}
};
Object.setPrototypeOf(obj1, proto); //将一个指定的对象的原型设置为另一个对象
console.log(obj1.find() )  //super，指向当前对象的原型对象。

4. 对象的扩展运算符

let { p1, p2, ...p3 } ={ p1: 1, p2: 2, p3: 3, p4: 4 };
console.log(p1, p2, p3) // 1 2 {p3: 3, p4: 4}

对象的新增方法

1. object.assign()

Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）（浅拷贝）

const target  = {a:1};
const source1 = {b:2};
const source2 = {c:3};
Object.assign(target,source1,source2) 
console.log(target) //Object {a:1,b:2,c:3}

• 有多个原对象同名属性，后面的属性会覆盖前面的属性

 const target1 = { a: 1, b: 1 };
const source11 = { b: 2, c: 2 };
const source21 = { c: 3 };
Object.assign(target1, source11, source21);
console.log(target1)// {a:1, b:2, c:3}

• 除了字符串会以数组形式，拷贝入目标对象，其他值都不会产生效果。

const v1 = 'abc';
const v2 = true;
const v3 = 10;
const obj = Object.assign({}, v1, v2, v3);
console.log(obj); // { "0": "a", "1": "b", "2": "c" }

• 浅拷贝性质

const obj1 = {a: {b: 1}};
const obj2 = Object.assign({}, obj1);
obj1.a.b = 2;
console.log( obj2.a.b) //2

Symbol

1. 凡是属性名属于 Symbol 类型，就都是独一无二的，可以保证不会与其他属性名产生冲突。

• 创建Symbol

let firstName1 = Symbol();
let person1 = {};
person1[firstName1] = "liaomei";
console.log(person1[firstName1]); // "liaomei"

• symbol.for()

使用Symbol.for()方法也可以创建一个Symbol类型的值，但是此方法和Symbol()的一个重要区别是，
它不会重复创建具有相同键的值，也就是说此方法在创建一个值之前，
首先会搜索是否已经具有指定键的Symbol类型的值，如果有则返回这个Symbol值，否则新创建一个Symbol值。

let one = Symbol.for("哈哈哈哈");
let two = Symbol.for("哈哈哈哈");
console.log(typeof one);  //symbol
console.log(one == two);  //true

• Symbol.keyFor()

此方法会获取对应Symbol值的键。

let s = Symbol.for("嘻嘻嘻嘻");
console.log(Symbol.keyFor(s));  //嘻嘻嘻嘻