ES6入門 ___ 對象的擴展

一、屬性的簡介表示法

ES6允許直接寫入變量和函數(shù)作為對象的屬性和方法。允許在對象中只寫屬性名，不寫屬性值。這時，屬性值等于屬性名所代表的變量。

var foo = 'bar'
var baz = {foo}
baz
 // {foo: "bar"} 

// 等同于
var baz = {foo: foo}

除了屬性簡寫，方法也可以簡寫

var o = {
  method() {
    return 'Hello！'
  }
}

// 等同于
var o = {
  method: function() {
    return 'Hello！'
  }
}

這種寫法用于函數(shù)的返回值會非常方便，CommonJS 模塊輸出變量也非常適合使用簡介寫法

屬性的復制器（setter）和取值器（getter）事實上也采用了這種寫法

var cart = {
  _wheels: 4,

  get wheels() {
    return this._wheels
  },
  set wheels(value) {
    if (value < this._wheels) {
      throw new Error('數(shù)值太小了')
    }
    this._wheels = value
  }
}

注意：簡介寫法中屬性名總是字符串，這回導致一些看上去比較奇怪的結(jié)果。

var obj = {
  class() {}
}

// 等同于
var obj = {
  'class': function() {}
}

class 是字符串，所以不會因為它屬于關(guān)鍵字而導致語法解析錯誤。如果是一個 Generator 函數(shù)，則需要在前面加上星號

二、屬性名表達式

JavaScript 語言定義對象的屬性有兩種方法

// 方法一
obj.foo = true

// 方法二
obj.['a' + 'bc'] = 123

如果使用字面量方式定義對象（使用大括號），則在 ES5 中只能使用方法一（標識符）定義屬性

var obj = {
  foo: true,
  abc: 123
}

ES6 允許字面量定義對象時使用方法二（表達式作為對象的屬性名），即表達式放在方括號內(nèi)。

let propKey = 'foo'

let obj = {
  [propKey]: true,
  ['a' + 'bc']: 123
}
console.dir(obj)

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

let obj = {
  ['h' + 'ello']() {
    return 'hi'
  }
}

obj.hello()

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

// 報錯
var foo = 'bar'
var bar = 'abc'
var baz = { [foo] }

// 正確寫法
var foo = 'bar'
var baz = { [foo]: 'abc' }

屬性名表達式如果是一個對象，默認情況下會自動將對象轉(zhuǎn)為字符串[object Object]，這一點要特別小心

const keyA = {a: 1}
const keyB = {b: 2}

const myObject = {
  [keyA]: 'valueA',
  [keyB]: 'valueB'
}

myObject
// {[object Object]: "valueB"}

上面的代碼中，[keyA] 和 [keyB] 得到的都是[object Object]，所以 [keyB] 會把 [keyA] 覆蓋掉，而 myObject 最后只有一個 [object Object] 屬性。

三、方法的 name 屬性

函數(shù)的 name 屬性返回函數(shù)名。對象方法也是函數(shù)，因此也有 name 屬性

const person = {
  sayName() {
    console.log('Hello')
  }
}
person.sayName.name
// "sayName"

如果對象的方法使用了取值函數(shù)（getter）和存值函數(shù)（setter），則name 屬性不是在該方法上面，而是在該方法屬性的描述對象的 get 和 set 屬性上面，返回值是方法名 前加上 get 和 set

const obj = {
  get foo() {},
  set foo(x) {}
}
obj.foo.name
// TypeError: Cannot read property 'name' of undefined

const descriptor = Object.getOwnPropertyDescriptor(obj, 'foo')
descriptor.get.name // "get foo"
descriptor.set.name // "set foo"

有兩種特殊情況：bind 方法創(chuàng)造的函數(shù)，name 屬性返回 “bound”加上原函數(shù)的名字；Function 構(gòu)造函數(shù)創(chuàng)造的函數(shù)，name 屬性返回“anonymous”

如果對象的方法是一個 Symbol 值，那么 name 屬性返回的是這個 Symbol 值的描述

const key1 = Symbol('description')
const key2 = Symbol()

let obj = {
  [key1]() {},
  [key2]() {}
}
obj[key1].name // "[description]"
obj[key2].name // ""

四、Object.is()

ES6 提出了“Same-value equality”（同值相等）。Object.is 就是部署這個算法的新方法。用來比較兩個值是否嚴格相等，與嚴格運算符（===）的行為基本一致。

Object.is('foo', 'foo')
// true

Object.is({}, {})
// false

與（===）不同之處只有兩個：一個 +0 不等于 -0， 二是NaN 等于自身

+0 === -0 // true
NaN === NaN // false

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

五、Object.assign()

5.1、基本用法

Object.assign 方法用于將源對象（source）的所有可枚舉屬性復制到目標對象（target）

var target = {a: 1}

var source1 = {b: 2}
var source2 = {c: 3}

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

Object.assign 方法的第一個參數(shù)是目標對象，后面的參數(shù)都是源對象。如果目標對象和源對象有同名屬性，或多個源對象有同名屬性，則后面的屬性會覆蓋前面的屬性。

  • 如果只有一個參數(shù)，Object.assign 會直接返回該參數(shù)
  • 如果該參數(shù)不是對象，則會先轉(zhuǎn)成對象，然后返回
  • 由于 undefined 和 null 無法轉(zhuǎn)成對象，所以如果將他們作為參數(shù)，就會報錯。
    如果非對象參數(shù)出現(xiàn)在源對象的位置（即非首參數(shù)），那么處理規(guī)則則將有所不同。首先，這些參數(shù)都會轉(zhuǎn)成對象，如果無法轉(zhuǎn)成對象便會跳過。這意味著，如果undefined 和 null 不在首參數(shù)便不會報錯。

其他類型的值（即數(shù)值、字符串 和 布爾值）不在首參數(shù)也不會報錯。但是，除了字符串會以數(shù)組形式復制到目標對象，其他值都不會產(chǎn)生效果。

var v1 = 'abc'
var v2 = true
var v3 = 10

var obj = Object.assign({}, v1, v2, v3)
obj // {0: "a", 1: "b", 2: "c"}

上面代碼中，數(shù)值和布爾值被忽略。這是因為只有字符串的包裝對象會產(chǎn)生可枚舉屬性

Object(true) // {[ [PrimitiveValue] ]: true}
Object(10) // {[[ PrimitiveValue]]: 10}
Object('abc') // {0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: 'abc'}

原始值都在包裝對象的內(nèi)部屬性 [[ PrimitiveValue ]] 上面，這個屬性是不會被 Object.assign 復制的。只有字符串的包裝對象會產(chǎn)生可枚舉的實義屬性，那些屬性則會被拷貝

Object.assign 復制的屬性是有限制的，只復制源對象的自身屬性（不復制繼承屬性）。也不復制不可枚舉的屬性（enumerable: false）

Object.assign({b: 'c'}, Object.defineProperty({}, 'invisible', {
  enumerable: false,
  value: 'hello'
}))
// {b: "c"}

屬性名為 Symbol 值的屬性也會被 Object.assign 復制。

Object.assign({a: 'b'}, { [Symbol('c')]: 'd' })
// {a: "b", Symbol(c): "d"}

5.2、注意點

  1. Object.assign 方法實現(xiàn)的是淺復制，而不是深復制。也就是說，如果源對象某個屬性的值是對象，那么目標對象復制得到的是這個對象的引用。
  2. 一旦遇到同名屬性，Object.assign 的處理方法是替換而不是添加。

5.3、常見用途

1. 為對象添加屬性

class Point {
  constructor(x, y) {
    Object.assign(this, {x, y})
  }
}

2. 為對象添加方法

Object.assign(SomeClass.prototype, {
  someMethod(arg1, arg2) {
    // todo
  },
  anotherMethod() {

  }
})

// 等同于下面的寫法
SomeClass.prototype.someMethod = function (arg1, arg2) {
  // todo
}
SomeClass.prototype.anotherMethod = function () {
  // todo
}

3. 克隆對象

function clone(origin) {
  return Object.assign({}, origin)
}

如果想要保持繼承鏈，可以采用下面的代碼。

function clone(origin) {
  let originProto = Object.getPrototypeOf(origin)
  return Object.assign(Object.create(originProto), origin)
}

4. 合并對個對象
將對個對象合并到某個對象

const merge = (target, ...sources) => Object.assign(target, ...sources)

如果希望合并后返回一個新對象，可以改寫上面的函數(shù)，對一個空對象合并

const merge = (...source) => Object.assign({}, ...sources)

5. 為屬性指定默認值

const DEFAULTS = {
  logLevel: 0,
  outputFormat: 'html'
}

function processContent(options) {
  options = Object.assign({}, DEFAULTS, options)
  console.log(options)
 // ...
}

如果 DEFAULTS 和 options 對象中有同名屬性，則 options 的屬性會會覆蓋 DEFAULTS 的屬性值

  • 由于存在深復制的問題，DEFAULTS 對象和 options 對象的所有屬性的值都只能是簡單類型，而不能指向另一個對象，否則將導致 DEFAULTS 對象的該屬性不起作用。

六、屬性的可枚舉性

對象的每一個屬性都具有一個描述對象（Descriptor），用于控制該屬性的行為。Object.getOwnPropertyDescriptor方法可以獲取該屬性的描述對象

let obj = {foo: 123}

Object.getOwnPropertyDescriptor(obj, 'foo')
/* {
     configurable: true
     enumerable: true
     value: 123  
     writable: true
  {
*/

描述對象的 enumerable 屬性稱為“可枚舉屬性”，如果該屬性為 false，就表示某些操作會忽略當前屬性。

ES5 有3個 操作會忽略 enumerable 為 false 的屬性

  • for...in 循環(huán)：只遍歷對象自身的和繼承的可枚舉屬性
  • Object.keys()：返回對象自身的所有可枚舉屬性的鍵名
  • JSON.stringify()：只串行化對象自身的可枚舉屬性

ES6 新增了 1 個操作 Object.assign()，會忽略 enumerable 為 false 的屬性，只復制自身的可枚舉屬性

引入 enumerable 的最初目的就是讓某些屬性可以規(guī)避掉 for...in 操作。比如，對象原型的 toString 方法以及數(shù)組的 length 屬性

此外，ES6 規(guī)定，所有 Class 的原型方法都是不可枚舉的

Object.getOwnPropertyDescriptor(class {foo() {}}.prototype, 'foo').enumerable
// false

總的來說，操作中引入繼承的屬性會讓問題復雜化，大多數(shù)時候，我們只關(guān)心對象自身的屬性。所以，盡量不要用 for...in 循環(huán)，而用 Object.keys() 代替

七、屬性的遍歷

ES6 一共有 5種 方法可以遍歷對象的屬性。
1. for...in
for...in 循環(huán)遍歷對象自身的和繼承的可枚舉屬性（不含 Symbol 屬性）
2. Object.keys(obj)
Object.keys 返回一個數(shù)組，包括對象自身的（不含繼承）所有可枚舉屬性（不含 Symbol屬性）
3. Object.getOwnPropertyNames(obj)
Object.getOwnPropertyNames 返回一個數(shù)組，包含對象自身的所有屬性（不含 Symbol屬性，但是包括不可枚舉屬性）
4. Object.getOwnPropertySymbols(obj)
Object.getOwnPropertySymbols 返回一個數(shù)組，包含對象自身的所有 Symbol 屬性
5. Reflect.ownKeys(obj)
Reflect.ownKeys 返回一個數(shù)組，包含對象自身的所有屬性，不管屬性名是 Symbol 還是字符串，也不管是否可枚舉

以上五種方法遍歷對象的屬性時都遵守同樣的屬性遍歷次序規(guī)則。

  • 首先遍歷所有屬性名為數(shù)值的屬性，按照數(shù)字排序
  • 其次遍歷所有屬性名為字符串的屬性，按照生成時間排序
  • 最后遍歷所有的屬性名為Symbol 值的屬性，按照生成時間排序。

八、proto屬性、Object.setPrototypeOf()、Object.getPrototypeOf()

8.1、proto屬性

proto 屬性用來讀取或設(shè)置當前對象的 prototype 對象。目前，所有瀏覽器（包括 IE11）都部署了這個屬性

var obj = { /*...*/ }

obj.__proto__

該屬性沒有寫入 ES6 的正文，而是寫入了 附錄，原因是 proto 前后的雙下劃線說明，它本質(zhì)上是一個內(nèi)部屬性，而不是一個正式的對外的 API，只是由于瀏覽器廣泛支持，才被加入 ES6。標準明確規(guī)定，只有瀏覽器必須部署這個屬性，其他運行環(huán)境不一定要部署。

新的代碼最好認為這個屬性是不存在的。因為，無論從語義的角度，還是從兼容的角度，都不要使用這個屬性，而是使用Object.setPrototypeOf()（寫操作）、Object.getPrototypeOf()（讀操作）或 Object.create()（生成操作）代替。

8.2、Object.setPrototypeOf()

Object.setPrototypeOf 方法的作用 與 proto 相同，用來設(shè)置一個對象的 prototype 對象，返回參數(shù)對象本身。它是 ES6 正式推薦的設(shè)置原型對象的方法。

// 格式
Object.setPrototypeOf(obj, prototype)

// 用法
var o = Object.setPrototypeOf({}, null)

如果第一個參數(shù)不是對象，則會自動轉(zhuǎn)為對象。但是由于返回的還是第一個參數(shù)，所以這個操作不會產(chǎn)生任何效果。

Object.setPrototypeOf(1, {}) === 1 // true
Object.setPrototypeOf('foo', {}) === 'foo' // true
Object.setPrototypeOf(true, {}) === true // true

由于 undefined 和 null 無法轉(zhuǎn)為對象，所以如果第一個參數(shù)是 undefined 或 null 就會報錯。

8.3、Object.getPrototypeOf()

該方法與 setPrototypeOf 方法配套，用于讀取一個對象prototype 對象。

Object.getPrototypeOf(obj)

與 Object.setPrototypeOf() 類似

  • 如果參數(shù)不是對象，則會被自動轉(zhuǎn)為對象。
  • 如果參數(shù)是 undefined 或 null，他們無法轉(zhuǎn)為對象就會報錯。

九、Object.keys()、Object.values()、Object.entries()

9.1、Object.keys()

ES5 引進了 Object.keys 方法，返回一個數(shù)組，成員是參數(shù)對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵名。

var obj = {foo: 'bar', baz: 42}
Object.keys(obj)

ES2017 中有一個提案，其中引入了與 Object.keys 配套的Object.values 和 Object.entries 作為遍歷一個對象的補充手段，供 for...of 循環(huán)使用。

9.2、Object.values()

Object.values 方法返回一個數(shù)組，成員是參數(shù)對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值。

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

下面是 Object.values 的注意點：

  • Object.values 只返回對象自身的可遍歷屬性
  • Object.values 會過濾屬性名為 Symbol 值的屬性
  • 如果 Object.values 方法的參數(shù)是一個字符串，則會返回各個字符組成的一個數(shù)組
  • 如果參數(shù)不是對象，Object.values 會先將其轉(zhuǎn)為對象。由于數(shù)值和布爾值包裝對象都不會為實例添加非繼承的屬性，所以O(shè)bject.values會返回空數(shù)組。

9.3、Object.entries()

Object.entries 方法返回一個數(shù)組，成員是參數(shù)對象自身的（不含繼承的）所有可遍歷（enumerable）屬性的鍵值對數(shù)組

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

除了返回值不一樣，該方法的行為與 Object.values 基本一致

如果該對象的屬性名是一個 Symbol 值，該屬性會被忽略

Object.entries({ [Symbol() ]: 123, foo: 'abc'})
// [ ["foo", "abc"] ]

Object.entries 的基本用途是遍歷對象的屬性

let obj = {one: 1, two: 2}
for(let [k, v] of Object.entries(obj)) {
  console.log(`${JSON.stringify(k)}: ${JSON.stringify(v)}`)
}
// "one": 1
// "two": 2

Object.entries 方法的另一個用處是將對象轉(zhuǎn)為真正的 Map 結(jié)構(gòu)

var obj = {foo: 'bar', baz: 42}
var map = new Map(Object.entries(obj))
map // Map(2) {"foo" => "bar", "baz" => 42}

十、對象的擴展運算符

ES2017 將擴展運算符引入了對象

解構(gòu)賦值
對象的解構(gòu)賦值用于從一個對象取值，相當于將所有可遍歷的、但尚未被讀取的屬性分配到指定的對象上面。所有的鍵和它們的值都會復制到新對象上面

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

以下是對象解構(gòu)賦值的主要事項：

  • 由于解構(gòu)賦值要求等號右邊是一個對象，所以如果等號右邊是undefined 或 null 就會報錯，因為他們無法轉(zhuǎn)為對象
  • 解構(gòu)賦值必須是最后一個參數(shù)，否則會報錯
  • 解構(gòu)賦值的復制是淺復制，即如果一個鍵的值是復合類型的值（數(shù)組、對象、函數(shù)），那么解構(gòu)值復制的是這個值的引用，而不是這個值的副本。
  • 解構(gòu)賦值不會復制繼承自原型對象的屬性

解構(gòu)賦值的一個用處是擴展某個函數(shù)的參數(shù)，引入其他操作

function baseFunction({a, b}) {
  // ...
}

function wrapperFunction({x, y, ...restConfig}) {
  // 使用 x 和 y參數(shù)進行操作
  // 其余參數(shù)傳給原始函數(shù)
  return baseFunction(...restConfig)
}

函數(shù) wrapperFunction 在 baseFunction 的基礎(chǔ)上進行了擴展，能夠接受多余的參數(shù)并且保留原始函數(shù)的行為。

擴展運算符

擴展運算符（...）用于取出參數(shù)對象的所有可遍歷屬性，將其復制到當前對象之中。

let z = {a: 3, b: 4}
let n = {...z}
n // {a: 3, b: 4}

這等同于使用 Object.assign 方法

let aClone = { ...a }

// 等同于
let aClone = Object.assign({}, a)

如果想完整克隆一個對象，還要復制對象原型的屬性，可以采用以下方法

// 方法一
const clone1 = {
  __proto__: Object.getPrototypeOf(obj),
  ...obj
}

// 方法二
const clone2 = Object.assign(
  Object.create(Object.getPrototypeOf(obj)),
  obj
)

推薦使用寫法二，因為 __proto__屬性在非瀏覽器的環(huán)境不一定部署

擴展運算符可用于合并兩個對象

let ab = {...a, ...b}
// 等同于
let ab = Object.assign({}, a, b)
  • 如果用戶自定義的屬性放在擴展運算符后面，則擴展運算符內(nèi)部的同名屬性會被覆蓋。
    這個特性試驗用來修改現(xiàn)有對象的部分屬性 
let newVersion = {
  ...previousVersion,
  name: 'New Name' // Override the name prototype
}
  • 如果把自定義屬性放在擴展運算符前面，就變成了設(shè)置新對象的默認屬性值。
  • 與數(shù)組的擴展運算符一樣，對象的擴展運算符后面可以有表達式。
  • 如果擴展運算符后面是一個空對象，則沒有任何效果
  • 如果擴展運算符的參數(shù)是 null 或 undefined，則這兩個值會被忽略，不會報錯

如果擴展運算符的參數(shù)對象之中有取值函數(shù) get，這個函數(shù)將會執(zhí)行。

let a = {}
let runtimeError = {
  ...a,
  ...{
    get x() {
      throw new Error('getter running')
    }
  }
}

以上代碼會拋出錯誤，因為 x 屬性被執(zhí)行了

十一、Object.getOwnPropertyDescriptors()

ES5 的Object.getOwnPropertyDescriptor 方法用來返回某個對象屬性的描述對象（descriptor）

var obj = {p: 'a'}

Object.getOwnPropertyDescriptor(obj, 'p')
// {value: "a", writable: true, enumerable: true, configurable: true}

ES2017 引入了 Object.getOwnPropertyDescriptors 方法，返回指定對象所有自身屬性（非繼承屬性）的描述對象

const obj = {
  foo: 123,
  get bar() {
    return 'abc'
  }
}

Object.getOwnPropertyDescriptors(obj)
/*
{
  bar: {get: ?, set: undefined, enumerable: true, configurable: true},
  foo: {value: 123, writable: true, enumerable: true, configurable: true}
}
*/

該方法的引入主要是為了解決 Object.assign() 無法正確復制 get 屬性 和 set 屬性的問題。

const source = {
  set foo(value) {
    console.log(value)
  }
}

const target1 = {}
Object.assign(target1, source)

Object.getOwnPropertyDescriptor(target1, 'foo')
// {value: undefined, writable: true, enumerable: true, configurable: true}

Object.getOwnPropertyDescriptors 方法配合 Object.defineProperties 方法就可以實現(xiàn)正確復制。

const source = {
  set foo(value) {
    console.log(value)
  }
}

const target2 = {}
Object.defineProperties(target2, Object.getOwnPropertyDescriptors(source))
Object.getOwnPropertyDescriptor(target2, 'foo')
// {get: undefined, set: ?, enumerable: true, configurable: true}

Object.getOwnPropertyDescriptors 方法的另一個用處是，配合 Object.create 方法將對象屬性克隆島一個新對象。這屬于淺復制

const clone = Object.create(
  Object.getPrototypeOf(obj), 
  Object.getOwnPropertyDescriptors(obj)
)

// 或者
const shallowClone = obj => Object.create(
  Object.getPrototypeOf(obj),
  Object.getOwnPropertyDescriptors(obj)
)

另外，Object.getOwnPropertyDescriptors 方法可以實現(xiàn)一個對象繼承另一個對象。

const obj = Object.create(
  port,
  Object.getOwnPropertyDescriptors({
    foo: 123
  })
)

Object.getOwnPropertyDescriptors 也可以用來實現(xiàn) Mixin（混入）模式

let mix = object => ({
  with: (...mixins) => mixins.reduce(
    (c, mixin) => Object.create(
      c,
      Object.getOwnPropertyDescriptors(mixin)
    ),
    object
  )
})

let a = {a: 'a'}
let b = {b: 'b'}
let c = {c: 'c'}

let d = mix(c).with(a, b)
d.c // "c"
d.b // "b"
d.a // "a"

上面的代碼返回一個新的對象 d，代表了對象 a 和 b 被混入了對象 c 的操作

十二、Null 傳導運算符

編程業(yè)務(wù)中，如果讀取對象內(nèi)部的某個屬性，往往需要判斷該對象是否存在。這樣的一些列操作需要用到大量的短路運算符，現(xiàn)在有一個提案，其中引入了“Null傳導運算符”（null propagation operator）?.

“Null 傳導運算符” 有 4 種用法

  • obj?.prop：讀取對象屬性
  • obj?.[expr]：同上
  • func?.(...args)：函數(shù)或?qū)ο蠓椒ǖ恼{(diào)用
  • new C?.(...args)：構(gòu)造函數(shù)的調(diào)用

傳導運算符之所以寫成 obj?.prop，而不是 obj?prop，是為了方便編譯器能夠區(qū)分三元運算符 ?:

// 如果 a 是null 或 undefined，返回 undefined
// 否則 返回 a.b.c() .d
a?.b.c().d

// 如果a是 null 或 undefined，下面的語句不產(chǎn)生任何效果
// 否則執(zhí)行 a.b = 42
a?.b = 42

// 如果 a 是 null 或 undefined，下面的語句不產(chǎn)生任何效果
delete a?.b
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時請結(jié)合常識與多方信息審慎甄別。
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • 國家電網(wǎng)公司企業(yè)標準（Q/GDW）- 面向?qū)ο蟮挠秒娦畔?shù)據(jù)交換協(xié)議 - 報批稿：20170802 前言： 排版 ...
    庭說閱讀 12,378評論 6贊 13
  • 1.屬性的簡潔表示法 允許直接寫入變量和函數(shù) 上面代碼表明，ES6 允許在對象之中，直接寫變量。這時，屬性名為變量...
    雨飛飛雨閱讀 1,262評論 0贊 3
  • 函數(shù)和對象 1、函數(shù) 1.1 函數(shù)概述 函數(shù)對于任何一門語言來說都是核心的概念。通過函數(shù)可以封裝任意多條語句，而且...
    道無虛閱讀 4,945評論 0贊 5
  • 三，字符串擴展 3.1 Unicode表示法 ES6 做出了改進，只要將碼點放入大括號，就能正確解讀該字符。有了這...
    eastbaby閱讀 1,668評論 0贊 8
  • 屬性的簡潔表示法 ES6允許直接寫入變量和函數(shù)，作為對象的屬性和方法。 上面代碼表明，ES6允許在對象之中，直接寫...
    oWSQo閱讀 568評論 0贊 0

友情鏈接更多精彩內(nèi)容