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

資訊專欄INFORMATION COLUMN

【JavaScript必知】深度挖掘 Object 對象的使用

stefan / 2121人閱讀

摘要:所有引用類型的原型鏈都可以追溯到構造函數屬性內置的一些構造函數有等等它們主要有兩個共有的屬性。而構造函數創建對象除了上面的操作以外還會運行構造函數。利用與構造函數實現繼承對象關系相關學習文章中和的區別和關系

介紹

在javascript中, 數據類型主要分為原始類型和引用類型兩種。而一切引用類型都來自于Object的拷貝。所有引用類型的原型鏈都可以追溯到 Object

Object 構造函數屬性

JavaScript 內置的一些構造函數有 Object, Function, Number, String, Boolean, Array, RegExp 等等, 它們主要有兩個共有的屬性。

length 構造函數參數個數

prototype 構造函數原型對象

Object原型鏈

Object.getPrototypeOf

Object.isPrototypeOf

Object.hasOwnProperty

一切引用對象的原型都來自 Object.prototype

測試各個數據類型的引用情況

var a = {},
    b = [],
    c = function () {},
    d = Function,
    e = String;
[a, b, c, d, e].forEach(function (val) {
    // all return true
    console.log(val instanceof Object);
});

每一個引用類型對象, 都含有一個原型屬性__proto__, 它負責控制對象的原型屬性和方法的查詢使用

創建無Object.prototype的原型鏈對象
// method 1
var obj1 = Object.create(null);

// method 2
var obj2 = {};
Object.setPrototypeOf(obj2, null);

// method 3
var obj3 = {};
obj3.__proto__ = null;

[obj1, obj2, obj3].forEach(function (item) {
  console.log(item instanceof Object); // false
});
__proto__prototype

__proto__ 隱式原型, prototype 顯示原型.
實例對象通過隱式原型__proto__ 匹配找到對應的函數和屬性. 而prototype是每一個構造函數都存在的一個屬性。其中prototype 包含 constructor屬性

var o = {};
"__proto__" in o; // return true, 說明 字面量對象存在一個隱式屬性

// 指定隱式屬性
function Foo () {}
o.__proto__ = Foo.prototype;

o instanceof Foo; // return true
o instanceof Object; // return true
設置隱藏原型屬性
var o = {};
"__proto__" in o;

function Foo () {}
function Bar () {}
Bar.prototype = new Foo();
Bar.prototype.constructor = Bar;

// 方法一, 直接設置 __proto__值
o.__proto__ = Foo.prototype;
console.log(o instanceof Foo); // return true;

// 方法二, 使用 setPrototypeOf
Object.setPrototypeOf(o, Bar.prototype); // 設置新原型
console.log(o instanceof Bar); // return true;

// 獲取對象隱式屬性
Object.getPrototypeOf(o) === Bar.prototype; // return true

// 檢查原型 是否存在于對象屬性的鏈中
Bar.prototype.isPrototypeOf(o); // true
Foo.prototype.isPrototypeOf(o); // true
Object.prototype.isPrototypeOf(o); // true
獲取對象的實例屬性

Object.keys

Object.getOwnPropertyNames

// return []
Object.keys(Object.prototype)

// return ["constructor", "__defineGetter__", "__defineSetter__", "hasOwnProperty", "__lookupGetter__", "__lookupSetter__", "isPrototypeOf", "propertyIsEnumerable", "toString", "valueOf", "__proto__", "toLocaleString"]
Object.getOwnPropertyNames(Object.prototype)

Object.keys 返回一個對象的實例可枚舉屬性, 如果使用了Object.defineProperty改變了對象的某個屬性, 則無法通過Object.keys返回屬性進行遍歷屬性, 也無法使用 for-in循環。

var obj = {
    foo: function () {}
};

// return ["foo"]
Object.keys(obj);

Object.defineProperty(obj, "foo", {
   enumerable: false
});

// return []
Object.keys(obj);

// empty loop
for (var name in obj) {
  console.log(name);
}

// return false
obj.hasOwnProperty("foo");

Object.getOwnPropertyNames() 返回自身實例屬性名稱, 無視enumerable: false

var obj = {
    foo: function () {},
    bar: "hello world"
};

Object.defineProperty(obj, "foo", {
    // foo 已被定義, 所以需要顯示設置 false
    enumerable: false
});

Object.defineProperty(obj, "foo2", {
    value: function () {},
    // foo2 未被定義, 默認enumerable為false
    enumerable: true
});

// "bar", "foo2"
Object.keys(obj);

// "foo", "bar", "foo2"
Object.getOwnPropertyNames(obj);

"foo" in obj // return true

in 操作符, 檢查屬性是否在能夠獲取, 無視屬性

對象定義屬性

Object.defineProperty

Object.getOwnPropertyDescriptor

屬性描述一般是由enumrable, value, get, set, configurable, writeable, value 組成, 其中 get, setvalue 為互斥關系

定義一個對象的描述
var obj = Object.create(null);

Object.defineProperty(obj, "foo", {
    value: "foo",
    configurable: false,
    writeable: false,
    enumerable: false
});

obj.foo = "change foo";
console.log(obj.foo); // still foo

Object.defineProperty(obj, "foo", {
    writeable: true,
    configurable: true
});

obj.foo = "change foo 2";
console.log(obj.foo); // still foo
"foo" in obj; // return true

一旦被定義了configureable: false, 那么后續再次 defineProperty時不會生效。

writeable: false 的情況下, 無法修改屬性的 value

屬性描述中的 valueget, set
var obj = Object.create(null);

// throw Error 
// Uncaught TypeError: Invalid property descriptor. 
// Cannot both specify accessors and a value or writable attribute
Object.defineProperty(obj, "foo", {
    value: "foo",
    set: function (val) {
        // this 指向 obj
        this._foo = val;
    },
    get: function () {
        return this._foo;
    }
});

因為 valueget, set 為互斥關系, 所以無法同時進行定義。

writeableget, set
var obj = Object.create(null);

Object.defineProperty(obj, "foo", {
    // 失效
    writeable: false,
    set: function (val) {
        // this 指向 obj
        this._foo = val;
    },
    get: function () {
        return this._foo;
    }
});

obj.foo = "abc"; // set()
obj._foo === obj.foo  // return true
console.log(obj.foo); // return "abc"
"foo" in obj // return true

writeable 失效, 無法對屬性做任何限制

重復定義對象的屬性
var obj = Object.create(null);

Object.defineProperty(obj, "foo", {
    configurable: false,
    value: "foo"
});

// Uncaught TypeError: Cannot redefine property: foo
Object.defineProperty(obj, "foo", {
    value: "foo2"
});

一旦定義了configurable: false以后, 不允許再次定義 descriptor

獲取對象的屬性描述
var obj = Object.create(null);

Object.defineProperty(obj, "foo", {
    configurable: true,
    value: "foo"
});
var descriptor = Object.getOwnPropertyDescriptor(obj, "foo");

console.log(descrptor); // {value: "foo", writable: false, enumerable: false, configurable: false}

// {foo: {value: "foo", writable: false, enumerable: false, configurable: false}}
Object.getOwnPropertyDescriptors(obj);
對象拷貝 淺拷貝

Object.assign

將候選的對象里的可枚舉屬性進行引用賦值, 支持多個候選的對象傳遞

var o = {
  foo: "foo",
  bar: "bar"
};

Object.defineProperty(o, "foo", {
  enumerable: false
});

var obj = Object.assign(Object.create(null), o, {
  o: o
});

/*
obj = {
  bar: "bar",
  o: {
    "foo": "foo",
    "bar": "bar"
  }
}
*/
obj.o === o; // return true;

由于Object.assign 處于淺拷貝的關系, 所以返回的key 都為簡單的引用方式.

深度拷貝

使用 對象系列化方式copy數據格式

// 該方法只能拷貝基本數據類型
var obj = {a: 1, b: 2, c: function () { console.log("hello world");}, d: {e: 3, f: 4}};

JSON.parse(JSON.stringify(obj));

自行實現深度拷貝

function deepClone (obj) {
  var newObj;
  var isPlainObject = function (o) {
    return Object.prototype.toString.call(o) === "[object Object]";
  };
  var isArray = function (o) {
    return Object.prototype.toString.call(o) === "[object Array]";
  };
  if (isArray(obj)) {
    newObj = [];
    for (var i = 0, len = obj.length; i < len; i++) {
      newObj.push(deepClone(obj[i]));
    }
  } else if (isPlainObject(obj)) {
    newObj = {};
    for (var key in obj) {
      newObj[key] = deepClone(obj[key]);
    }
  } else {
    newObj = obj;
  }
  return newObj;
}

var o = {a: 1, b: [{c: 2, d: 3}]};
var o2 = deepClone(o);
o.b[0] !== o2.b[0]; // return true

深度拷貝對象函數, 內置的對象和數組都被完整的拷貝出來。

循環引用拷貝問題

var o = {a: 1, b: 2};

// 循環引用問題
o.foo = o;

// Uncaught TypeError: Converting circular structure to JSON
JSON.stringify(o);

// Uncaught RangeError: Maximum call stack size exceeded
deepClone(o);

// 將循環引用的key設置為不可枚舉型
Object.defineProperty(o, "foo", {enumerable: false});
// OK {"a":1,"b":2}
JSON.stringify(o);

避免重復循環引用的深度clone

function deepClone (obj) {

  var objStack = [];

  var isPlainObject = function (o) {
    return Object.prototype.toString.call(o) === "[object Object]";
  };

  var isArray = function (o) {
    return Object.prototype.toString.call(o) === "[object Array]";
  };
  
  var isError = function (o) {
    return o instanceof Error;
  };

  function _deepClone (obj) {
    var newObj, cloneObj;
    if (isArray(obj) || isPlainObject(obj)) {
      // 對象重復引用
      if (objStack.indexOf(obj) === -1) {
        objStack.push(obj);
      } else {
        return new Error("parameter Error. it is exits loop reference");
      }
    }
    if (isArray(obj)) {
      newObj = [];
      for (var i = 0, len = obj.length; i < len; i++) {
        cloneObj = _deepClone(obj[i]);
        if (!isError(cloneObj)) {
          newObj.push(cloneObj);
        }
      }
    } else if (isPlainObject(obj)) {
      newObj = {};
      for (var key in obj) {
        cloneObj = _deepClone(obj[key]);
        if (!isError(cloneObj)) {
          newObj[key] = cloneObj;
        }
      }
    } else {
      newObj = obj;
    }
    return newObj;
  }
  return _deepClone(obj);
}
Object.create 創建對象實例

一般創建對象有三種方式

字面量方式 var o = {};

構造函數方式 var o = new Object();

Object.create();

Object.create 與 字面量創建的區別

Object.create 可以指定創建的對象的隱式原型鏈 __proto__, 也可以創建空原型鏈的的對象

var prototype = {
  foo: "foo",
  name: "prototoype"
};
var o = Object.create(prototype);
var o2 = Object.create(null);
o.__proto__ === prototype; // true

"__protot__" in o2; // false

Object.create 與構造函數的區別

Object.create 直接進行開辟對象空間, 綁定隱式原型鏈屬性。而構造函數創建對象除了上面的操作以外, 還會運行構造函數。

利用 Object.create 與構造函數, 實現繼承對象關系

// Shape - superclass
function Shape() {
  this.x = 0;
  this.y = 0;
}

// superclass method
Shape.prototype.move = function(x, y) {
  this.x += x;
  this.y += y;
  console.info("Shape moved.");
};

// Rectangle - subclass
function Rectangle() {
  Shape.call(this); // call super constructor.
}

// subclass extends superclass
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

console.log("Is rect an instance of Rectangle?",
  rect instanceof Rectangle); // true
console.log("Is rect an instance of Shape?",
  rect instanceof Shape); // true
rect.move(1, 1); // Outputs, "Shape moved."
相關學習文章

js中__proto__prototype的區別和關系?

Object MDN API

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

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

相關文章

  • 《JSON必知必會》學習筆記(一)

    摘要:基于對象字面量,但是獨立于任何編程語言,真正重要的是表示法本身,所以在學習之前不必先學習。鍵必須是字符串,值可以是合法的數據類型字符串數字對象數組布爾值或。布爾類型中的布爾值僅可使用小寫形式或,其他任何寫法都會報錯。 什么是JSON JSON全稱是Javascript Object Notation(對象表示法),是一種在不同平臺間傳遞數據的文本格式(數據交換格式)。常見的數據交換格式...

    rickchen 評論0 收藏0
  • 《JSON必知必會》學習筆記(一)

    摘要:基于對象字面量,但是獨立于任何編程語言,真正重要的是表示法本身,所以在學習之前不必先學習。鍵必須是字符串,值可以是合法的數據類型字符串數字對象數組布爾值或。布爾類型中的布爾值僅可使用小寫形式或,其他任何寫法都會報錯。 什么是JSON JSON全稱是Javascript Object Notation(對象表示法),是一種在不同平臺間傳遞數據的文本格式(數據交換格式)。常見的數據交換格式...

    imccl 評論0 收藏0
  • 某熊技術之路指北 ?

    某熊的技術之路指北 ? 當我們站在技術之路的原點,未來可能充滿了迷茫,也存在著很多不同的可能;我們可能成為 Web/(大)前端/終端工程師、服務端架構工程師、測試/運維/安全工程師等質量保障、可用性保障相關的工程師、大數據/云計算/虛擬化工程師、算法工程師、產品經理等等某個或者某幾個角色。某熊的技術之路系列文章/書籍/視頻/代碼即是筆者蹣跚行進于這條路上的點滴印記,包含了筆者作為程序員的技術視野、...

    shadowbook 評論0 收藏0

發表評論

0條評論

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