av激情亚洲男人的天堂国语,日韩欧美精品一中文字幕,无码av一区二区三区无码,国产又色又爽又刺激的a片,国产又色又爽又刺激的a片

這6點知識讓我對JavaScript的對象有了更進一步的了解

1. 對象方法 & this

成都創(chuàng)新互聯(lián)企業(yè)建站,10余年網(wǎng)站建設(shè)經(jīng)驗，專注于網(wǎng)站建設(shè)技術(shù)，精于網(wǎng)頁設(shè)計，有多年建站和網(wǎng)站代運營經(jīng)驗，設(shè)計師為客戶打造網(wǎng)絡(luò)企業(yè)風(fēng)格，提供周到的建站售前咨詢和貼心的售后服務(wù)。對于成都網(wǎng)站建設(shè)、成都網(wǎng)站制作中不同領(lǐng)域進行深入了解和探索，創(chuàng)新互聯(lián)在網(wǎng)站建設(shè)中充分了解客戶行業(yè)的需求，以靈動的思維在網(wǎng)頁中充分展現(xiàn)，通過對客戶行業(yè)精準(zhǔn)市場調(diào)研，為客戶提供的解決方案。

方法只是保存函數(shù)值的屬性。

簡單對象方法

 
 
 
 
    
  
  
  
  
  1. let rabbit = {};
    2. 
  
  
  
  
  2. rabbit.speak = function(line) {
    3. 
  
  
  
  
  3.     console.log("小兔子說： "+ line );
    4. 
  
  
  
  
  4. };
    5. 
  
  
  
  
  5. rabbit.speak("我還活著。")
    6.

輸出：

 
 
 
 
    
  
  
  
  
  1. T小兔子說： 我還活著。
    2.

對象方法 & this

當(dāng)一個函數(shù)作為方法被調(diào)用時，對象會將函數(shù)作為屬性并立即調(diào)用，就像在object.method()中一樣，其主體中的特殊變量this將指向被調(diào)用的對象。

 
 
 
 
    
  
  
  
  
  1. function speak(line) {
    2. 
  
  
  
  
  2.   console.log(this.type + "小兔子說：" + line)
    3. 
  
  
  
  
  3. };
    4. 
  
  
  
  
  4. let whiteRabbit = {type: "白色", speak: speak}
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. whiteRabbit.speak("噢，我真可愛！")
    7.

輸出：

 
 
 
 
    
  
  
  
  
  1. 白色小兔子說：噢，我真可愛！
    2.

apply & call

 
 
 
 
    
  
  
  
  
  1. function speak(line) {
    2. 
  
  
  
  
  2.   console.log(`${this.type}的小兔子說：${line}` );
    3. 
  
  
  
  
  3. };
    4. 
  
  
  
  
  4. let whiteRabbit = {type: "白色", speak: speak};
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. speak.apply(whiteRabbit, ["你這個小壞蛋!"]);
    7. 
  
  
  
  
  7. speak.call({type: "黑色"}, "嘿嘿，我不壞，你不愛!");
    8. 
 
 
 
 
 
 
 
 
    
  
  
  
  
  1. 白色的小兔子說：你這個小壞蛋!
    2. 
  
  
  
  
  2. 黑色的小兔子說：嘿嘿，我不壞，你不愛!
    3.

2.Prototype(原型)

  • 幾乎所有的對象都有一個prototype
  • prototype是另一個用作屬性的備用源的對象
  • 當(dāng)一個對象訪問自身沒有屬性時，它會從它的prototype搜索該屬性，如果沒有找到就繼續(xù)從它的prototype的prototype查找，依此類推，直到 null 為止。

空對象的原型

原型鏈最終的指向是Object的prototype, 而Object中的__proto__是null

 
 
 
 
    
  
  
  
  
  1. let empty = {};
    2. 
  
  
  
  
  2. console.log(empty.toString);
    3. 
  
  
  
  
  3. console.log(empty.toString());
    4.

輸出：

 
 
 
 
    
  
  
  
  
  1. [Function: toString]
    2. 
  
  
  
  
  2. [object Object]
    3.

其他對象(數(shù)組、函數(shù)等等)的默認屬性

  • 許多對象沒有直接將Object.prototype作為自己的原型，但有自己的默認屬性
  • 從Function.prototype派生的函數(shù)和從Array.prototype派生的數(shù)組
 
 
 
 
    
  
  
  
  
  1. console.log(Object.getPrototypeOf(isNaN) ==
    2. 
  
  
  
  
  2.             Function.prototype);
    3. 
  
  
  
  
  3. console.log(Object.getPrototypeOf([]) ==
    4. 
  
  
  
  
  4. Array.prototype);
    5.

輸出：

 
 
 
 
    
  
  
  
  
  1. true
    2. 
  
  
  
  
  2. true
    3.
  • Object.create 創(chuàng)建具有特定原型的對象
  • protoRabbit充當(dāng)所有兔子共享的屬性的容器

單個兔子對象(如殺手兔子)包含僅適用于自身的屬性(在本例中為type)，并從其原型派生共享屬性

 
 
 
 
    
  
  
  
  
  1. let protoRabbit = {
    2. 
  
  
  
  
  2.   speak: function (line) {
    3. 
  
  
  
  
  3.     console.log(`${this.type}兔子說：${line}` );
    4. 
  
  
  
  
  4.   }
    5. 
  
  
  
  
  5. }
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. let killerRabbit = Object.create(protoRabbit)
    8. 
  
  
  
  
  8. killerRabbit.type = '殺手'
    9. 
  
  
  
  
  9. killerRabbit.speak('準(zhǔn)備受死吧！')
    10.

輸出：

 
 
 
 
    
  
  
  
  
  1. 殺手兔子說：準(zhǔn)備受死吧！
    2.

3.構(gòu)造函數(shù)

— 構(gòu)造函數(shù)原型

  • 創(chuàng)建從某個共享原型派生的對象的更方便的方法是使用構(gòu)造函數(shù)
  • 在 JavaScript 中，調(diào)用前面帶有new關(guān)鍵字的函數(shù)會將其視為構(gòu)造函數(shù)
  • 構(gòu)造函數(shù)將其this變量綁定到一個新對象，除非它顯式返回另一個對象值，否則此新對象將從調(diào)用中返回
  • 用new創(chuàng)建的對象被稱為是其構(gòu)造函數(shù)的實例
  • 約定將構(gòu)造函數(shù)的名稱大寫，以便于與其他函數(shù)區(qū)分開
 
 
 
 
    
  
  
  
  
  1. function Rabbit(type) {
    2. 
  
  
  
  
  2.     this.type = type;
    3. 
  
  
  
  
  3. }
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. let killerRabbit = new Rabbit("killer");
    6. 
  
  
  
  
  6. let blackRabbit = new Rabbit("black");
    7. 
  
  
  
  
  7. console.log(blackRabbit.type);
    8.

輸出：

 
 
 
 
    
  
  
  
  
  1. black
    2.

— 默認情況下，構(gòu)造函數(shù)具有Object.prototype

  • 構(gòu)造函數(shù)(實際上是所有函數(shù))會自動獲取一個名為prototype的屬性，默認情況下，該屬性包含一個從Object.prototype派生的普通空對象
  • 使用此構(gòu)造函數(shù)創(chuàng)建的每個實例都將此對象作為其原型
 
 
 
 
    
  
  
  
  
  1. function Rabbit(type) {
    2. 
  
  
  
  
  2.   this.type = type;
    3. 
  
  
  
  
  3. }
    4. 
  
  
  
  
  4. 
  
  
  
  
  5. let blackRabbit = new Rabbit("黑色");
    6. 
  
  
  
  
  6. Rabbit.prototype.speak = function(line) {
    7. 
  
  
  
  
  7.   console.log(`${this.type}的兔子說：${line}` );
    8. 
  
  
  
  
  8. };
    9. 
  
  
  
  
  9. blackRabbit.speak("Boom...一波王炸！");
    10.

輸出：

 
 
 
 
    
  
  
  
  
  1. 黑色的兔子說：Boom...一波王炸！
    2.

4. 重寫派生屬性

— 相同的原型名稱

  • 如果原型中有同名的屬性，則不會更改此屬性
  • 該屬性被添加到對象本身
 
 
 
 
    
  
  
  
  
  1. function Rabbit(type) {
    2. 
  
  
  
  
  2.     this.type = type;
    3. 
  
  
  
  
  3. }
    4. 
  
  
  
  
  4. let blackRabbit = new Rabbit("black");
    5. 
  
  
  
  
  5. let killerRabbit = new Rabbit("killer");
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. Rabbit.prototype.teeth = "small";
    8. 
  
  
  
  
  8. console.log(killerRabbit.teeth);
    9. 
  
  
  
  
  9. // small
    10. 
  
  
  
  
  10. killerRabbit.teeth = "long, sharp, and bloody";
    11. 
  
  
  
  
  11. console.log(killerRabbit.teeth);
    12. 
  
  
  
  
  12. // long, sharp, and bloody
    13. 
  
  
  
  
  13. console.log(blackRabbit.teeth);
    14. 
  
  
  
  
  14. // small
    15. 
  
  
  
  
  15. console.log(Rabbit.prototype.teeth);
    16. 
  
  
  
  
  16. // small
    17.

下面 console.log(blackRabbit.teeth)的結(jié)果是small，因為blackRabbit對象不具有teeth屬性，它繼承自Rabbit對象自己的teeth屬性，值為 small。

5. 原型的干擾

— 可枚舉與不可枚舉

 
 
 
 
    
  
  
  
  
  1. let map = {}
    2. 
  
  
  
  
  2. 
  
  
  
  
  3. function storePhi(event, phi) {
    4. 
  
  
  
  
  4.   map[event] = phi
    5. 
  
  
  
  
  5. }
    6. 
  
  
  
  
  6. 
  
  
  
  
  7. storePhi('pizza', 0.069)
    8. 
  
  
  
  
  8. storePhi('touched tree', -0.081)
    9. 
  
  
  
  
  9. 
  
  
  
  
  10. Object.prototype.nonsense = 'hi'
    11. 
  
  
  
  
  11. 
  
  
  
  
  12. for(let name in map) {
    13. 
  
  
  
  
  13.   console.log(name)
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. 
  
  
  
  
  16. console.log('nonsense' in map)
    17. 
  
  
  
  
  17. console.log('toString' in map)
    18.

輸出結(jié)果:

 
 
 
 
    
  
  
  
  
  1. pizza
    2. 
  
  
  
  
  2. touched tree
    3. 
  
  
  
  
  3. nonsense
    4. 
  
  
  
  
  4. true
    5. 
  
  
  
  
  5. true
    6.

toString沒有出現(xiàn)在for/in循環(huán)中，但是in運算符中返回true，這是因為 JS 區(qū)分可枚舉屬性和不可枚舉屬性。

我們通過簡單分配創(chuàng)建的所有屬性都是可枚舉的，Object.prototype中的標(biāo)準(zhǔn)屬性都是不可改變的，這就是為什么它們不出現(xiàn)在這樣的for/in循環(huán)中的原因。

 
 
 
 
    
  
  
  
  
  1. let map = {};
    2. 
  
  
  
  
  2. function storePhi(event, phi) {
    3. 
  
  
  
  
  3.     map[event] = phi;
    4. 
  
  
  
  
  4. }
    5. 
  
  
  
  
  5. 
  
  
  
  
  6. storePhi("pizza", 0.069);
    7. 
  
  
  
  
  7. storePhi("touched tree", -0.081);
    8. 
  
  
  
  
  8. 
  
  
  
  
  9. Object.defineProperty(Object.prototype, "hiddenNonsense",
    10. 
  
  
  
  
  10.                 {enumerable: false, value: "hi"})
    11. 
  
  
  
  
  11. 
  
  
  
  
  12. for (var name in map) {
    13. 
  
  
  
  
  13.     console.log(name)
    14. 
  
  
  
  
  14. }
    15. 
  
  
  
  
  15. 
  
  
  
  
  16. console.log(map.hiddenNonsense)
    17.

輸出：

 
 
 
 
    
  
  
  
  
  1. pizza
    2. 
  
  
  
  
  2. touched tree
    3. 
  
  
  
  
  3. hi
    4.

通過使用Object.defineproperty函數(shù)可以定義自己的不可枚舉屬性，該函數(shù)允許我們控制要創(chuàng)建的屬性的類型，在該示例中，hiddenNonsense在 map 中，但在 for...in 中不會顯示。

— hasOwnProperty vs in 操作符

 
 
 
 
    
  
  
  
  
  1. const map = {}
    2. 
  
  
  
  
  2. console.log("toString" in map)
    3. 
  
  
  
  
  3. console.log(map.hasOwnProperty("toString"))
    4.

輸出：

 
 
 
 
    
  
  
  
  
  1. true
    2. 
  
  
  
  
  2. false
    3.

hasOwnProperty方法告訴我們對象本身是否具有該屬性，而無需查看其原型,這通常是比in運算符提供給我們的信息更有用的信息。

因此，如果你對基礎(chǔ)對象原型感到困惑時，建議你可以這樣寫for/in循環(huán):

 
 
 
 
    
  
  
  
  
  1. for (var name in map) {
    2. 
  
  
  
  
  2.     if (map.hasOwnProperty(name)) {
    3. 
  
  
  
  
  3.         // ... this is an own property
    4. 
  
  
  
  
  4.     }
    5. 
  
  
  
  
  5. }
    6.

6.無原型對象

Object.create函數(shù)使我們能夠創(chuàng)建具有特定原型的對象。我們還可以傳遞null作為原型，用來創(chuàng)建不帶原型的新對象。

因此，我們不再需要hasOwnProperty，因為對象擁有的所有屬性都是它自己的屬性。現(xiàn)在，無論人們對Object.prototype做了什么，我們都可以安全地使用for/in循環(huán)

 
 
 
 
    
  
  
  
  
  1. var map = Object.create(null);
    2. 
  
  
  
  
  2. map["pizza"] = 0.069;
    3. 
  
  
  
  
  3. console.log("toString" in map);
    4. 
  
  
  
  
  4. // false
    5. 
  
  
  
  
  5. console.log("pizza" in map);
    6. 
  
  
  
  
  6. // true
    7.

作者：Valentino Gagliardi 譯者：前端小智 來源：valentinog

原文：https://medium.com/javascript-in-plain-english/six-things-you-should-know-about-objects-in-javascript-ccd11a9e1998

本文轉(zhuǎn)載自微信公眾號「 大遷世界」，可以通過以下二維碼關(guān)注。轉(zhuǎn)載本文請聯(lián)系****公眾號。


當(dāng)前文章：這6點知識讓我對JavaScript的對象有了更進一步的了解
URL網(wǎng)址：http://uogjgqi.cn/article/cocjgdg.html
掃二維碼與項目經(jīng)理溝通

我們在微信上24小時期待你的聲音

解答本文疑問/技術(shù)咨詢/運營咨詢/技術(shù)建議/互聯(lián)網(wǎng)交流