?🌈個人主頁：前端青山
🔥系列專欄：Javascript篇
🔖人終將被年少不可得之物困其一生

依舊青山,本期給大家帶來Javascript篇專欄內容:Es6-對象新增了哪些擴展？

目錄

一、參數

二、屬性

函數的length屬性

name屬性

三、作用域

四、嚴格模式

五、箭頭函數

1、屬性的簡寫

2、屬性名表達式

3、super關鍵字

4、擴展運算符的應用

5、屬性的遍歷

六、對象新增的方法

Object.is()

Object.assign()

Object.getOwnPropertyDescriptors()

Object.setPrototypeOf()

Object.getPrototypeOf()

Object.keys()

Object.values()

Object.entries()

Object.fromEntries()

參考文獻

一、參數

ES6允許為函數的參數設置默認值

function log(x, y = 'World') {console.log(x, y);
}
?
console.log('Hello') // Hello World
console.log('Hello', 'China') // Hello China
console.log('Hello', '') // Hello

函數的形參是默認聲明的，不能使用let或const再次聲明

function foo(x = 5) {let x = 1; // errorconst x = 2; // error
}

參數默認值可以與解構賦值的默認值結合起來使用

function foo({x, y = 5}) {console.log(x, y);
}
?
foo({}) // undefined 5
foo({x: 1}) // 1 5
foo({x: 1, y: 2}) // 1 2
foo() // TypeError: Cannot read property 'x' of undefined

上面的foo函數，當參數為對象的時候才能進行解構，如果沒有提供參數的時候，變量x和y就不會生成，從而報錯，這里設置默認值避免

function foo({x, y = 5} = {}) {console.log(x, y);
}
?
foo() // undefined 5

參數默認值應該是函數的尾參數，如果不是非尾部的參數設置默認值，實際上這個參數是沒發省略的

function f(x = 1, y) {return [x, y];
}
?
f() // [1, undefined]
f(2) // [2, undefined]
f(, 1) // 報錯
f(undefined, 1) // [1, 1]

二、屬性

函數的length屬性

length將返回沒有指定默認值的參數個數

(function (a) {}).length // 1
(function (a = 5) {}).length // 0
(function (a, b, c = 5) {}).length // 2

rest 參數也不會計入length屬性

(function(...args) {}).length // 0

如果設置了默認值的參數不是尾參數，那么length屬性也不再計入后面的參數了

(function (a = 0, b, c) {}).length // 0
(function (a, b = 1, c) {}).length // 1

name屬性

返回該函數的函數名

var f = function () {};// ES5
f.name // ""// ES6
f.name // "f"

如果將一個具名函數賦值給一個變量，則 name屬性都返回這個具名函數原本的名字

const bar = function baz() {};
bar.name // "baz"
Function構造函數返回的函數實例，name屬性的值為anonymous(new Function).name // "anonymous"
bind返回的函數，name屬性值會加上bound前綴function foo() {};
foo.bind({}).name // "bound foo"(function(){}).bind({}).name // "bound "

三、作用域

一旦設置了參數的默認值，函數進行聲明初始化時，參數會形成一個單獨的作用域

等到初始化結束，這個作用域就會消失。這種語法行為，在不設置參數默認值時，是不會出現的

下面例子中，y=x會形成一個單獨作用域，x沒有被定義，所以指向全局變量x

let x = 1;function f(y = x) { // 等同于 let y = x  let x = 2; console.log(y);
}f() // 1

四、嚴格模式

只要函數參數使用了默認值、解構賦值、或者擴展運算符，那么函數內部就不能顯式設定為嚴格模式，否則會報錯

// 報錯
function doSomething(a, b = a) {'use strict';// code
}// 報錯
const doSomething = function ({a, b}) {'use strict';// code
};// 報錯
const doSomething = (...a) => {'use strict';// code
};const obj = {// 報錯doSomething({a, b}) {'use strict';// code}
};

五、箭頭函數

使用“箭頭”（=>）定義函數

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

如果箭頭函數不需要參數或需要多個參數，就使用一個圓括號代表參數部分

var f = () => 5;
// 等同于
var f = function () { return 5 };var sum = (num1, num2) => num1 + num2;
// 等同于
var sum = function(num1, num2) {return num1 + num2;
};

如果箭頭函數的代碼塊部分多于一條語句，就要使用大括號將它們括起來，并且使用return語句返回

var sum = (num1, num2) => { return num1 + num2; }

如果返回對象，需要加括號將對象包裹

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

注意點：

• 函數體內的this對象，就是定義時所在的對象，而不是使用時所在的對象

• 不可以當作構造函數，也就是說，不可以使用new命令，否則會拋出一個錯誤

• 不可以使用arguments對象，該對象在函數體內不存在。如果要用，可以用 rest 參數代替

• 不可以使用yield命令，因此箭頭函數不能用作 Generator 函數

1、屬性的簡寫

ES6中，當對象鍵名與對應值名相等的時候，可以進行簡寫

const baz = {foo:foo}
?
// 等同于
const baz = {foo}

方法也能夠進行簡寫

const o = {method() {return "Hello!";}
};
?
// 等同于
?
const o = {method: function() {return "Hello!";}
}

在函數內作為返回值，也會變得方便很多

function getPoint() {const x = 1;const y = 10;return {x, y};
}
?
getPoint()
// {x:1, y:10}

注意：簡寫的對象方法不能用作構造函數，否則會報錯

const obj = {f() {this.foo = 'bar';}
};
?
new obj.f() // 報錯

2、屬性名表達式

ES6 允許字面量定義對象時，將表達式放在括號內

let lastWord = 'last word';
?
const a = {'first word': 'hello',[lastWord]: 'world'
};
?
a['first word'] // "hello"
a[lastWord] // "world"
a['last word'] // "world"

表達式還可以用于定義方法名

let obj = {['h' + 'ello']() {return 'hi';}
};
?
obj.hello() // hi

注意，屬性名表達式與簡潔表示法，不能同時使用，會報錯

// 報錯
const foo = 'bar';
const bar = 'abc';
const baz = { [foo] };
?
// 正確
const foo = 'bar';
const baz = { [foo]: 'abc'};

注意，屬性名表達式如果是一個對象，默認情況下會自動將對象轉為字符串[object Object]

const keyA = {a: 1};
const keyB = {b: 2};
?
const myObject = {[keyA]: 'valueA',[keyB]: 'valueB'
};
?
myObject // Object {[object Object]: "valueB"}

3、super關鍵字

this關鍵字總是指向函數所在的當前對象，ES6 又新增了另一個類似的關鍵字super，指向當前對象的原型對象

const proto = {foo: 'hello'
};
?
const obj = {foo: 'world',find() {return super.foo;}
};
?
Object.setPrototypeOf(obj, proto); // 為obj設置原型對象
obj.find() // "hello"

4、擴展運算符的應用

在解構賦值中，未被讀取的可遍歷的屬性，分配到指定的對象上面

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
x // 1
y // 2
z // { a: 3, b: 4 }

注意：解構賦值必須是最后一個參數，否則會報錯

解構賦值是淺拷貝

let obj = { a: { b: 1 } };
let { ...x } = obj;
obj.a.b = 2; // 修改obj里面a屬性中鍵值
x.a.b // 2，影響到了結構出來x的值

對象的擴展運算符等同于使用Object.assign()方法

5、屬性的遍歷

ES6 一共有 5 種方法可以遍歷對象的屬性。

• for...in：循環遍歷對象自身的和繼承的可枚舉屬性（不含 Symbol 屬性）

• Object.keys(obj)：返回一個數組，包括對象自身的（不含繼承的）所有可枚舉屬性（不含 Symbol 屬性）的鍵名

• Object.getOwnPropertyNames(obj)：回一個數組，包含對象自身的所有屬性（不含 Symbol 屬性，但是包括不可枚舉屬性）的鍵名

• Object.getOwnPropertySymbols(obj)：返回一個數組，包含對象自身的所有 Symbol 屬性的鍵名

• Reflect.ownKeys(obj)：返回一個數組，包含對象自身的（不含繼承的）所有鍵名，不管鍵名是 Symbol 或字符串，也不管是否可枚舉

上述遍歷，都遵守同樣的屬性遍歷的次序規則：

• 首先遍歷所有數值鍵，按照數值升序排列

• 其次遍歷所有字符串鍵，按照加入時間升序排列

• 最后遍歷所有 Symbol 鍵，按照加入時間升序排

Reflect.ownKeys({ [Symbol()]:0, b:0, 10:0, 2:0, a:0 })
// ['2', '10', 'b', 'a', Symbol()]

六、對象新增的方法

關于對象新增的方法，分別有以下：

• Object.is()

• Object.assign()

• Object.getOwnPropertyDescriptors()

• Object.setPrototypeOf()，Object.getPrototypeOf()

• Object.keys()，Object.values()，Object.entries()

• Object.fromEntries()

Object.is()

嚴格判斷兩個值是否相等，與嚴格比較運算符（===）的行為基本一致，不同之處只有兩個：一是+0不等于-0，二是NaN等于自身

+0 === -0 //true
NaN === NaN // false
?
Object.is(+0, -0) // false
Object.is(NaN, NaN) // true

Object.assign()

Object.assign()方法用于對象的合并，將源對象source的所有可枚舉屬性，復制到目標對象target

Object.assign()方法的第一個參數是目標對象，后面的參數都是源對象

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

注意：Object.assign()方法是淺拷貝，遇到同名屬性會進行替換

Object.getOwnPropertyDescriptors()

返回指定對象所有自身屬性（非繼承屬性）的描述對象

const obj = {foo: 123,get bar() { return 'abc' }
};
?
Object.getOwnPropertyDescriptors(obj)
// { foo:
// ?  { value: 123,
// ? ?  writable: true,
// ? ?  enumerable: true,
// ? ?  configurable: true },
// ? bar:
// ?  { get: [Function: get bar],
// ? ?  set: undefined,
// ? ?  enumerable: true,
// ? ?  configurable: true } }

Object.setPrototypeOf()

Object.setPrototypeOf方法用來設置一個對象的原型對象

Object.setPrototypeOf(object, prototype)
?
// 用法
const o = Object.setPrototypeOf({}, null);

Object.getPrototypeOf()

用于讀取一個對象的原型對象

Object.getPrototypeOf(obj);

Object.keys()

返回自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名的數組

var obj = { foo: 'bar', baz: 42 };
Object.keys(obj)
// ["foo", "baz"]

Object.values()

返回自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵對應值的數組

const obj = { foo: 'bar', baz: 42 };
Object.values(obj)
// ["bar", 42]

Object.entries()

返回一個對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值對的數組

const obj = { foo: 'bar', baz: 42 };
Object.entries(obj)
// [ ["foo", "bar"], ["baz", 42] ]

Object.fromEntries()

用于將一個鍵值對數組轉為對象

Object.fromEntries([['foo', 'bar'],['baz', 42]
])
// { foo: "bar", baz: 42 }

參考文獻

• ES6 入門教程