国产xxxx99真实实拍_久久不雅视频_高清韩国a级特黄毛片_嗯老师别我我受不了了小说

資訊專欄INFORMATION COLUMN

ES6對象的擴展及新增方法。

bladefury / 1451人閱讀

摘要:屬性的簡潔表示法允許直接寫入變量和函數,作為對象的屬性和方法。目前,只有對象方法的簡寫法可以讓引擎確認,定義的是對象的方法。對象的新增方法比較兩個值是否相等,只有兩個運算符相等運算符和嚴格相等運算符。它是正式推薦的設置原型對象的方法。

1.屬性的簡潔表示法

ES6允許直接寫入變量和函數,作為對象的屬性和方法。這樣的書寫更加簡潔。

</>復制代碼

  1. const foo = "bar";
  2. const baz = {foo};
  3. baz//{foo:"bar"}
  4. //等同于
  5. const baz = {foo:foo}

上面代碼表明,ES6允許在對象之中,直接寫變量。這時,屬性名為變量名,屬性值為變量的值。下面是另一個例子。

</>復制代碼

  1. function f(x,y){
  2. return {x,y}
  3. }
  4. //等同于
  5. function f(x,y){
  6. return {x:x,y:y};
  7. }
  8. f(1,2)//{x:1,y:2}

除了屬性簡寫,方法也可以簡寫。

</>復制代碼

  1. const o ={
  2. method(){
  3. return "Hello!"
  4. }
  5. }
  6. //等同于
  7. const o = {
  8. method:function(){
  9. return "Hellow";
  10. }
  11. }

下面是一個實際的例子。

</>復制代碼

  1. let birth = "2000/01/01";
  2. const Person ={
  3. name:"張三",
  4. //等同于birth:birth
  5. birth,
  6. //等同于hello :function()....
  7. hello(){
  8. console.log("我的名字是",this.name)
  9. }
  10. }

這種寫法用于函數的返回值,將會非常方便。

</>復制代碼

  1. function getPoint(){
  2. const x =1;
  3. const y = 10;
  4. return {x,y}
  5. }
  6. getPoint()//{x:1,y:10}

CommonJS模塊輸出一組變量,就非常合適使用簡潔寫法。

</>復制代碼

  1. let ms = {};
  2. function getItem(key){
  3. return key in ms ?ms[key]:null;
  4. }
  5. function setItem(key,value){
  6. ms[key] = value;
  7. }
  8. function clear(){
  9. ms={}
  10. }
  11. module.exports = {getItem,setItem,clear};
  12. //等同于
  13. module.exports = {
  14. getItem:getItem,
  15. setItem:setItem,
  16. clearLclear
  17. }

屬性的賦值器(setter)和取值器(getter),事實上也是采用這種寫法。

</>復制代碼

  1. const cart = {
  2. _wheels:4,
  3. get wheels(){
  4. return this._wheels;
  5. },
  6. set wheels (value){
  7. if(value
  8. 2.屬性名表達式
  9. JavaScript定義對象的屬性,有兩種方法。

  10. </>復制代碼

    1. //方法一
    2. obj.foo = true;
    3. //方法二
    4. obj["a"+"bc"] = 123;
  11. 上面代碼的方法一是直接用標識符作為屬性名,方法二是用表達式作為屬性名,這時將表達式放在方括號之內。
    但是,如果使用字面量定義對象(使用大括號),在ES5中只能使用方法一(標識符)定義屬性。

  12. </>復制代碼

    1. var obj ={
    2. foo:true,
    3. abc:123
    4. }
  13. ES6允許字面量定義對象時,用方法二作為對象的屬性名,即把表達式放在括號內。

  14. </>復制代碼

    1. let propKey = "foo";
    2. let obj ={
    3. [propKey]:true,
    4. ["a"+"bc"]:123
    5. }
  15. 下面是另一個例子:

  16. </>復制代碼

    1. let lastWord = "last word";
    2. const a = {
    3. "first word":"hello",
    4. [lastWord]:"world"
    5. };
    6. a["first word"]//hello
    7. a[lastWord]//world
    8. a["last word"]//world
  17. 表達式還可以用于定義方法名。

  18. </>復制代碼

    1. let obj = {
    2. ["h"+"ello"](){
    3. return "hi"
    4. }
    5. }
    6. obj.hello()//hi;
  19. 注意:

  20. </>復制代碼

    1. 屬性名表達式與簡潔表示法,不能同時使用,會報錯。
    2. 屬性名表達式如果是一個對象,默認情況下會自動將對象轉為字符串[object object],這一點要特別小心。
  21. </>復制代碼

    1. const keyA = {a:1};
    2. const keyB = {b:2};
    3. const myObject = {
    4. [keyA]:"valueA",
    5. [keyB]:"valueB"
    6. };
    7. myObject;// Object {[object Object]: "valueB"}
  22. 上面代碼中,[keyA][keyB]得到的都是[object object],所以[keyB]會把[keyA]覆蓋掉,而myObject最后只有一個[object object]屬性。

  23. 方法的name屬性
  24. 函數的name屬性,返回函數名。對象方法也是函數,因此也有name屬性。

  25. </>復制代碼

    1. const person = {
    2. sayName() {
    3. console.log("hello!");
    4. },
    5. };
    6. person.sayName.name // "sayName"
  26. 屬性的可枚舉型和遍歷
  27. 對象的每個屬性都有一個描述對象,用來控制改屬性的行為。Object.getOwnPropertyDescriptor(obj,"foo")方法可以獲取該屬性的描述對象。
    描述對象的enumerable屬性,稱為可枚舉性,如果該屬性為false,就表示某些操作會忽略當前的屬性。
    目前,有四個操作會忽略enumerable為false的屬性。

  28. </>復制代碼

    1. for...in循環:只遍歷對象自身的和繼承的可枚舉的屬性。(不包含Symbol屬性)
    2. Object.keys():返回對象自身的所有可枚舉的屬性的鍵名,返回一個數組。(不包含Symbol)
    3. JSON.stringify():只串行化對象自身的可枚舉的屬性。
    4. object.assign():忽略enumrable為false的屬性,只拷貝對象自身的可枚舉的屬性。
  29. ES6一共有5種方法可以遍歷對象的屬性。
    1for...in

  30. </>復制代碼

    1. for...in循環遍歷對象自身的和繼承的可枚舉屬性(不包含Symbol屬性)。
  31. (2)Object.keys(obj)

  32. </>復制代碼

    1. object.keys返回一個數組,包含對象自身的(不含繼承的)所有可枚舉屬性(不包含Symbol屬性)的鍵名。
  33. (3)Object.getOwnPropertyNames(obj)

  34. </>復制代碼

    1. 返回一個數組,包含對象自身的所有屬性(不含Symbol屬性,但是包括不可枚舉屬性)的鍵名。
  35. (4)Object.getOwnPropertySymbols(obj)

  36. </>復制代碼

    1. 返回一個數組,包含對象自身的所有Symbol屬性的鍵名。
  37. (5)Reflect.ownKeys(obj)

  38. </>復制代碼

    1. Reflect.ownKeys返回一個數組,包含對象自身的所有鍵名,不管鍵名是Symbol或字符串,也不管是否可枚舉。
  39. super關鍵字
  40. 我們知道,this關鍵字總是指向函數所在的當前對象,ES6又新增了另一個類似的關鍵字super,指向當前對象的原型對象。

  41. </>復制代碼

    1. const proto = {
    2. foo:"hello"
    3. };
    4. const obj = {
    5. foo:"world",
    6. find(){
    7. return super.foo;
    8. }
    9. };
    10. Object.setPrototypeOf(obj,proto);
    11. obj.find();//hello
  42. 上面代碼中,對象obj.find()方法之中,通過super.foo引用了原型對象protofoo屬性。
    注意:super關鍵字表示原型對象時,只能用在對象的方法之中,用在其他地方都會報錯。目前,只有對象方法的簡寫法可以讓Javascript引擎確認,定義的是對象的方法。
    JavaScript引擎內部,super.foo等同于Object.getPrototypeOf(this).fooObject.getPrototypeOf(this).foo.call(this)。

  43. 對象的擴展運算符
  44. 解構賦值
    對象的解構賦值用于從一個對象取值,相當于將目標對象自身的所有可遍歷、但尚未被讀取的屬性,分配到指定的對象上面。所有的鍵和它們的值,都會拷貝到新對象上面。

  45. </>復制代碼

    1. let{x,y,...z} = {x:1,y:2,a:3,b;4};
    2. x//1,
    3. y//2,
    4. z//{a:3,b:4}
  46. 上面代碼中,變量z是解構賦值所在的對象。它獲取等號右邊的所有尚未讀取的鍵(a和b),將它們連同值一起拷貝過來。

  47. 對象的新增方法
  48. 1.Object.is()
    ES5比較兩個值是否相等,只有兩個運算符:相等運算符和嚴格相等運算符。它們都有缺點,前者會自動轉換數據類型,后者的NaN不等于自身,以及+0等于-0。JavaScript缺乏一種運算,在所有環境中,只要兩個值是一樣的,它們就應該相等。
    ES6提出同值相等算法,用來解決這個問題。Object.is就是部署這個算法的新方法。它用來比較兩個值是否嚴格相等,與嚴格比較運算符的行為基本一致。(===)。

  49. </>復制代碼

    1. Object.is("foo","foo");
    2. //true
    3. Object.is({},{})
    4. //false
  50. 不同之處只有兩個:一是+0不等于-0,二是NaN等于自身。

  51. </>復制代碼

    1. +0 === -0 //true
    2. NaN === NaN // false
    3. Object.is(+0, -0) // false
    4. Object.is(NaN, NaN) // true
  52. ES5可以通過下面的代碼,部署Object.is

  53. </>復制代碼

    1. Object.defineProperty(Object,"is",{
    2. value:function(x,y){
    3. if(x===y){
    4. return x!=0||1/x===1/y;
    5. }
    6. return x!==x&&y!==y;
    7. },
    8. configurable:true,
    9. enumerable:false,
    10. writable:true
    11. })
  54. 2.Object.assign()
    Object.assign方法用于對象的合并,將源對象的所有可枚舉屬性,復制到目標對象。

  55. </>復制代碼

    1. const target = {a:1};
    2. const source1 = {b:2};
    3. const source2 = {c:3};
    4. Object.assign(target,source1,source2);
    5. target//{a:1,b:2,c:3}
  56. Object.assign方法的第一個參數是目標對象,后面的參數都是源對象。
    注意:如果目標對象與源對象有同名屬性,或多個源對象有同名屬性,則后面的屬性會覆蓋前面的屬性。
    如果只有一個參數,Object.assign會直接返回該參數。

  57. </>復制代碼

    1. const obj = {a:1};
    2. Obejct.assign(obj) === obj//true
  58. 如果該參數不是對象,則會先轉成對象,然后返回。

  59. </>復制代碼

    1. typeof Object.assign(2) // "object"
  60. 由于undefinednull無法轉成對象,所以如果它們作為參數,就會報錯。

  61. </>復制代碼

    1. Object.assign(undefined) // 報錯
    2. Object.assign(null) // 報錯
  62. 如果非對象參數出現在源對象的位置(即非首參數),那么處理規則有所不同。首先,這些參數都會轉成對象,如果無法轉成對象,就會跳過。這意味著,如果undefinednull不在首參數,就不會報錯。

  63. </>復制代碼

    1. let obj = {a: 1};
    2. Object.assign(obj, undefined) === obj // true
    3. Object.assign(obj, null) === obj // true
  64. 其它類型的值(即數值、字符串和布爾值)不在首參數,也不會報錯。但是,除了字符串會以數組形式,拷貝入目標對象,其它值都不會產生效果。

  65. </>復制代碼

    1. const v1 = "abc";
    2. const v2 = true;
    3. const v3 = 10;
    4. const obj = Object.assign({}, v1, v2, v3);
    5. console.log(obj); // { "0": "a", "1": "b", "2": "c" }
  66. 上面代碼中,v1,v2,v3分別是字符串、布爾值和數值,結果只有字符串合入目標對象(以字符串數組的形式),數值和布爾值都會被忽略。這是因為只有字符串的包裝對象,會產生可枚舉屬性。
    Object.assign拷貝的屬性是有限制的,只拷貝源對象的自身屬性(不拷貝繼承屬性),也不拷貝不可枚舉的屬性(enumerable:false)。

  67. </>復制代碼

    1. Object.assign({b: "c"},
    2. Object.defineProperty({}, "invisible", {
    3. enumerable: false,
    4. value: "hello"
    5. })
    6. )
    7. // { b: "c" }
  68. 上面代碼中,Object.assign要拷貝的對象只有一個不可枚舉屬性invisible,這個屬性并沒有被拷貝進去。
    屬性名為Symbol值的屬性,也會被Object.assign拷貝。

  69. </>復制代碼

    1. Object.assign({ a: "b" }, { [Symbol("c")]: "d" })
    2. // { a: "b", Symbol(c): "d" }
  70. 注意點:
    (1)淺拷貝
    Object.assign方法實行的是淺拷貝。也就是說,如果源對象某個屬性的值是對象,那么目標對象拷貝得到的是這個對象的引用。

  71. </>復制代碼

    1. const obj1 = {a: {b: 1}};
    2. const obj2 = Object.assign({}, obj1);
    3. obj1.a.b = 2;
    4. obj2.a.b // 2
  72. 上面代碼中,源對象obj1a屬性值是一個對象,Objec.assign拷貝得到的是這個對象的引用。這個對象的任何變化,都會反映到目標對象上面。
    (2)同名屬性的替換
    對于這種嵌套的對象,一旦遇到同名屬性,Obejct.assign的處理方法是替換,而不是添加。

  73. </>復制代碼

    1. const target = { a: { b: "c", d: "e" } }
    2. const source = { a: { b: "hello" } }
    3. Object.assign(target, source)
    4. // { a: { b: "hello" } }
  74. (3)數組的處理
    Object.assign可以用來處理數組,但是會把數組是為對象。

  75. </>復制代碼

    1. Object.assign([1,2,3],[4,5]);
    2. //[4,5,3]
  76. 上面代碼中,Oject.assign把數組視為屬性名為0,1,2的對象,因此源數組的0號屬性4覆蓋了目標數組的0號屬性1.
    (4)取值函數的處理
    Obejct.assign只能進行值的復制,如果要復制的值是一個取值函數,那么將求值后再復制。

  77. </>復制代碼

    1. const source = {
    2. get foo() { return 1 }
    3. };
    4. const target = {};
    5. Object.assign(target, source)
    6. // { foo: 1 }
  78. 上面代碼中,source對象的foo屬性是一個取值函數,Object.assign不會復制這個取值函數,只會拿到值以后,將這個值復制過去。

  79. 常見用途
  80. (1)為對象添加屬性

  81. </>復制代碼

    1. class Point{
    2. constructor(x,y){
    3. Object.assign(this,{x,y})
    4. }
    5. }
  82. 上面方法通過Obejct.assign方法,將x屬性和y屬性添加到Point類的對象實例。
    (2)為對象添加方法

  83. </>復制代碼

    1. Object.assign(SomeClass.prototype,{
    2. someMethod(arg1,arg2){},
    3. anotherMethod(){}
    4. });
    5. //等同于下面的寫法
    6. SOmeClass.prototype.someMethod = function(arg1,arg2){ }
    7. SomeClass.prototype.anotherMethod = function () {
    8. ···
    9. };
  84. 上面代碼使用了對象屬性的簡潔表示法,直接將兩個函數放在大括號中,再使用assign方法添加到SomeClass.prototype之中。
    3)克隆對象

  85. </>復制代碼

    1. function clone(origin){
    2. return Object.assign({},origin)
    3. }
  86. 上面代碼中將原始對象拷貝到一個空對象,就得到了原始對象的克隆。
    不過,采用這種方法克隆,只能克隆原始對象自身的值,不能克隆它繼承的值。如果想要保持繼承鏈,可以采用下面的代碼。

  87. </>復制代碼

    1. function clone(origin) {
    2. let originProto = Object.getPrototypeOf(origin);
    3. return Object.assign(Object.create(originProto), origin);
    4. }
  88. (4)合并多個對象

  89. </>復制代碼

    1. const merge =
    2. (target, ...sources) => Object.assign(target, ...sources);
  90. 如果希望合并后返回一個新對象,可以改寫上面函數,對一個空對象合并。

  91. </>復制代碼

    1. const merge =
    2. (...sources) => Object.assign({}, ...sources);
  92. (5)為屬性指定默認值

  93. </>復制代碼

    1. const DEFAULTS = {
    2. logLevel: 0,
    3. outputFormat: "html"
    4. };
    5. function processContent(options) {
    6. options = Object.assign({}, DEFAULTS, options);
    7. console.log(options);
    8. // ...
    9. }
  94. 上面代碼中,DEFAULTS對象是默認值,options對象是用戶提供的參數。Object.assign方法將DEFAULTSoptions合并成一個新對象,如果兩者有同名屬性,則option的屬性值會覆蓋DEFAULTS的屬性值。

  95. 3.Object.getOwnPropertyDescriptors()
    ES5Object.getWonPropertyDescriptor()方法會返回某個對象屬性的描述對象。ES2017Object.getOwnPropertyDescriptors()方法,返回指定對象所有自身屬性的描述對象。

  96. </>復制代碼

    1. const obj = {
    2. foo: 123,
    3. get bar() { return "abc" }
    4. };
    5. Object.getOwnPropertyDescriptors(obj)
    6. // { foo:
    7. // { value: 123,
    8. // writable: true,
    9. // enumerable: true,
    10. // configurable: true },
    11. // bar:
    12. // { get: [Function: get bar],
    13. // set: undefined,
    14. // enumerable: true,
    15. // configurable: true } }
  97. 上面代碼中,Object.getOwnPropertyDescriptors()方法返回一個對象,所有原對象的屬性名都是該對象的屬性名,對應的屬性值就是該屬性的描述對象。
    Object.defineProperties()方法。
    Object.defineProperties(obj,props)方法直接在一個對象上定義新的屬性或修改現有的屬性,并返回該對象。
    obj:在其上定義或修改屬性的對象。
    props:要定義其可枚舉屬性或修改屬性描述的對象。
    4.Object.setPrototypeOf()和Object.getPrototypeOf()。
    Obejct.setPrototypeOf方法的作用與__proto__相同,用來設置一個對象的prototype對象,返回參數對象本身。它是ES6正式推薦的設置原型對象的方法。

  98. </>復制代碼

    1. //格式
    2. Obejct.setPrototypeOf(object,prototype);
    3. //用法
    4. const o = Object.setPrototypeOf({},null);
  99. 該方法等同于下面的函數。

  100. </>復制代碼

    1. function setPrototypeOf(obj,proto){
    2. obj.__proto__ = proto;
    3. return obj;
    4. }
  101. 下面是一個例子。

  102. </>復制代碼

    1. let proto = {};
    2. let obj = {x:10};
    3. Obejct.setPrototypeOf(obj,proto);
    4. proto.y = 20;
    5. proto.z = 40;
    6. obj.x //10
    7. obj.y//20
    8. obj.z//40
  103. 上面代碼將proto對象設為obj對象的原型,所以從obj對象可以讀取proto對象的屬性。
    如果第一個參數不是對象,會自動轉為對象。但是由于返回的還是第一個參數,所以這個操作不會產生任何效果。
    由于undefinednull無法轉為對象,所以如果第一個參數是undefinednull,就會報錯。
    Object.getPrototypeOf()
    該方法與Object.setPrototypeOf方法配套,用于讀取一個對象的原型對象。

  104. </>復制代碼

    1. Object.getPrototypeOf(obj);
  105. 下面是一個例子。

  106. </>復制代碼

    1. function Rectangle() {
    2. // ...
    3. }
    4. const rec = new Rectangle();
    5. Object.getPrototypeOf(rec) === Rectangle.prototype
    6. // true
    7. Object.setPrototypeOf(rec, Object.prototype);
    8. Object.getPrototypeOf(rec) === Rectangle.prototype
    9. // false

文章版權歸作者所有,未經允許請勿轉載,若此文章存在違規行為,您可以聯系管理員刪除。

轉載請注明本文地址:http://m.specialneedsforspecialkids.com/yun/100907.html

相關文章

  • ES6學習 第六章 數值擴展

    摘要:前言本章介紹數值的擴展。本章原文鏈接數值的擴展進制表示法提供了二進制和八進制數值的新的寫法,分別用前綴或和或表示。科學計數法里面,表示指數的或前后不能有分隔符。函數返回數值的雙曲余弦函數可用表示。與數值的類型不同。 前言本章介紹數值的擴展。新增了很多方法,有些不常用的方法了解即可。本章原文鏈接:數值的擴展進制表...

    番茄西紅柿 評論0 收藏2637
  • 《深入理解ES6》筆記——擴展對象功能性(4)

    摘要:將對象的屬性拷貝到了對象,合并成一個新的對象。而這種行為也是新增的標準。總結本章講解了對象字面量語法拓展,新增方法,允許重復的對象字面量屬性,自有枚舉屬性排序,增強對象原型,明確了方法的定義。但是,就算把全部新增的功能記住也不是難事。 變量功能被加強了、函數功能被加強了,那么作為JavaScript中最普遍的對象,不加強對得起觀眾嗎? 對象類別 在ES6中,對象分為下面幾種叫法。(不需...

    baihe 評論0 收藏0
  • 通俗易懂理解ES6 - ES6變量類型Iterator

    摘要:迭代器在原有的數據結構類型上新增了兩種類型,我們在使用的時候還可以通過自由組合的形式使用這些結構類型達到自己想要的數據結構,這就需要一種統一的接口機制供我們調用處理不同的數據結構。 引言 萬丈高樓平地起,欲練此功,必先打好基本功: ) 在了解 ES6 新增的變量類型前,我們必須先知道 JavaScript 在ES6之前,有如下六種基本數據類型:Null、Undefined、Number...

    Keven 評論0 收藏0
  • 工作中常用es6+特性

    摘要:結合工作中使用情況,簡單對進行一些復習總結,包括常用的語法,等,以及短時間內要上手需要重點學習的知識點不同工作環境可能有一些差別,主要參考鏈接是阮一峰的博客以及外文博客阮老師大部分文章是直接翻譯的這個博客簡介先說一下,是一個標準化組織,他們 結合工作中使用情況,簡單對es6進行一些復習總結,包括常用的語法,api等,以及短時間內要上手需要重點學習的知識點(不同工作環境可能有一些差別),...

    xcold 評論0 收藏0

發表評論

0條評論

最新活動
閱讀需要支付1元查看
<