Làm cách nào để kiểm tra xem một đối tượng có thuộc tính cụ thể trong JavaScript không?

Làm cách nào để kiểm tra xem một đối tượng có thuộc tính cụ thể trong JavaScript không?

Xem xét:

x = {'key': 1};
if ( x.hasOwnProperty('key') ) {
    //Do this
}

Đó có phải là cách tốt nhất để làm điều đó?

Tôi thực sự bối rối trước những câu trả lời đã được đưa ra - hầu hết chúng đều hoàn toàn không chính xác. Tất nhiên bạn có thể có các thuộc tính đối tượng có giá trị không xác định, null hoặc sai. Vì vậy, chỉ cần giảm kiểm tra tài sản xuống typeof this[property]hoặc thậm chí tệ hơn, x.keysẽ cung cấp cho bạn kết quả hoàn toàn sai lệch.

Nó phụ thuộc vào những gì bạn đang tìm kiếm. Nếu bạn muốn biết liệu một vật thể có chứa một thuộc tính (và nó không đến từ đâu đó trên chuỗi nguyên mẫu) thì đó object.hasOwnPropertylà cách để đi. Tất cả các trình duyệt hiện đại đều hỗ trợ nó. (Nó bị thiếu trong các phiên bản Safari cũ hơn - 2.0.1 trở lên - nhưng những phiên bản trình duyệt đó hiếm khi được sử dụng nữa.)

Nếu những gì bạn đang tìm kiếm là nếu một đối tượng có thuộc tính trên đó có thể lặp lại (khi bạn lặp lại các thuộc tính của đối tượng, nó sẽ xuất hiện) thì sẽ thực hiện: prop in objectsẽ cho bạn hiệu ứng mong muốn.

Vì sử dụng hasOwnPropertycó thể là những gì bạn muốn và xem xét rằng bạn có thể muốn một phương pháp dự phòng, tôi trình bày cho bạn giải pháp sau:

var obj = {
    a: undefined,
    b: null,
    c: false
};

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );
}

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;
}

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true
};

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );
}

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);
}

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);
    }
}

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );
    }
}

Trên đây là một giải pháp hoạt động, đa trình duyệt, hasOwnPropertyvới một cảnh báo: Không thể phân biệt giữa các trường hợp có một thuộc tính giống hệt nhau trên nguyên mẫu và ví dụ - nó chỉ giả định rằng nó đến từ nguyên mẫu. Bạn có thể thay đổi nó để trở nên khoan dung hơn hoặc nghiêm khắc hơn, dựa trên tình huống của bạn, nhưng ít nhất điều này sẽ hữu ích hơn.

Với Underscore.jshoặc ( thậm chí tốt hơn ) lodash:

_.has(x, 'key');

Những cuộc gọi nào Object.prototype.hasOwnProperty, nhưng (a) ngắn hơn để gõ và (b) sử dụng "tham chiếu an toàn đến hasOwnProperty" (nghĩa là nó hoạt động ngay cả khi hasOwnPropertybị ghi đè).

Cụ thể, lodash định nghĩa _.haslà:

   function has(object, key) {
      return object ? hasOwnProperty.call(object, key) : false;
   }
   // hasOwnProperty = Object.prototype.hasOwnProperty

Thế còn?

var x = {'key': 1};

if ('key' in x) {
    console.log('has');
}

Lưu ý : hiện tại phần lớn đã lỗi thời nhờ chế độ nghiêm ngặt và hasOwnProperty. Giải pháp chính xác là sử dụng chế độ nghiêm ngặt và kiểm tra sự hiện diện của một tài sản bằng cách sử dụng obj.hasOwnProperty. Câu trả lời này có trước cả hai điều này, ít nhất là được thực hiện rộng rãi (vâng, nó đã cũ). Hãy làm như sau như một ghi chú lịch sử.

Xin lưu ý rằng undefined(không may) không phải là một từ dành riêng trong JavaScript nếu bạn không sử dụng chế độ nghiêm ngặt. Do đó, ai đó (một người khác, rõ ràng) có thể có ý tưởng lớn về việc xác định lại nó, phá vỡ mã của bạn.

Do đó, một phương pháp mạnh mẽ hơn là:

if (typeof(x.attribute) !== 'undefined')

Mặt khác, phương pháp này dài dòng hơn nhiều và cũng chậm hơn. : - /

Một lựa chọn phổ biến là để đảm bảo rằng undefinedđang thực sự không xác định, ví dụ như bằng cách đặt mã vào một chức năng mà chấp nhận một tham số bổ sung, được gọi là undefined, đó không phải là thông qua một giá trị. Để đảm bảo rằng nó không được thông qua một giá trị, bạn có thể tự gọi nó ngay lập tức, ví dụ:

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
})();

if (x.key !== undefined)

Armin Ronacher dường như đã đánh bại tôi , nhưng:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;
};

x = {'key': 1};

if (x.hasOwnProperty('key')) {
    alert('have key!');
}

if (!x.hasOwnProperty('bar')) {
    alert('no bar!');
}

Một giải pháp an toàn hơn, nhưng chậm hơn, như được chỉ ra bởi Konrad Rudolph và Armin Ronacher sẽ là:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== 'undefined';
};

Bạn có thể sử dụng intoán tử để kiểm tra xem thuộc tính có tồn tại trên một đối tượng không:

x = {'key': 1};
alert("key" in x);

Bạn cũng có thể lặp qua tất cả các thuộc tính của đối tượng bằng for - invòng lặp và sau đó kiểm tra thuộc tính cụ thể:

for (prop in x) {
    if (prop == "key") {
        //Do something
    }
}

Bạn phải xem xét nếu thuộc tính đối tượng này có thể đếm được hay không, bởi vì các thuộc tính không liệt kê sẽ không hiển thị trong một for-invòng lặp. Ngoài ra, nếu thuộc tính vô số đang che khuất một thuộc tính không thể đếm được của nguyên mẫu, nó sẽ không hiển thị trong Internet Explorer 8 trở về trước.

Nếu bạn muốn một danh sách tất cả các thuộc tính cá thể, cho dù có thể đếm được hay không, bạn có thể sử dụng

Object.getOwnPropertyNames(x);

Điều này sẽ trả về một mảng tên của tất cả các thuộc tính tồn tại trên một đối tượng.

Cuối cùng, bạn có thể sử dụng toán tử typeof để kiểm tra trực tiếp kiểu dữ liệu của thuộc tính đối tượng:

if (typeof x.key == "undefined") {
    alert("undefined");
}

Nếu thuộc tính không tồn tại trên đối tượng, nó sẽ trả về chuỗi không xác định. Khác nó sẽ trả lại loại tài sản thích hợp. Tuy nhiên, lưu ý rằng đây không phải lúc nào cũng là một cách kiểm tra hợp lệ xem một đối tượng có thuộc tính hay không, bởi vì bạn có thể có một thuộc tính được đặt thành không xác định, trong trường hợp đó, sử dụng typeof x.keyvẫn trả về đúng (mặc dù khóa vẫn là trong đối tượng).

Cập nhật: Bạn có thể kiểm tra xem một thuộc tính có tồn tại hay không bằng cách so sánh với thuộc tính javascript không xác định

if (x.key === undefined) {
    alert("undefined");
}

Điều này sẽ hoạt động trừ khi khóa được đặt cụ thể undefinedtrên đối tượng x

Chúng ta hãy vượt qua một số nhầm lẫn ở đây. Đầu tiên, hãy đơn giản hóa bằng cách giả sử hasOwnPropertyđã tồn tại; điều này đúng với phần lớn các trình duyệt hiện tại đang sử dụng.

hasOwnPropertytrả về true nếu tên thuộc tính được truyền cho nó đã được thêm vào đối tượng. Nó hoàn toàn độc lập với giá trị thực tế được gán cho nó có thể chính xác undefined.

Vì thế:

var o = {}
o.x = undefined

var a = o.hasOwnProperty('x')  // a is true
var b = o.x === undefined // b is also true

Tuy nhiên:

var o = {}

var a = o.hasOwnProperty('x')  // a is now false
var b = o.x === undefined // b is still true

Vấn đề là điều gì xảy ra khi một đối tượng trong chuỗi nguyên mẫu có thuộc tính với giá trị không xác định? hasOwnPropertysẽ là sai cho nó, và cũng sẽ như vậy !== undefined. Chưa,for..in vẫn sẽ liệt kê nó trong bảng liệt kê.

Điểm mấu chốt là không có cách trình duyệt chéo (vì Internet Explorer không lộ __prototype__) để xác định rằng một định danh cụ thể chưa được gắn vào một đối tượng hoặc bất cứ thứ gì trong chuỗi nguyên mẫu của nó.

Nếu bạn đang tìm kiếm một tài sản, thì "KHÔNG". Bạn muốn:

if ('prop' in obj) { }

Nói chung, bạn không nên quan tâm liệu tài sản đến từ nguyên mẫu hay đối tượng.

Tuy nhiên, vì bạn đã sử dụng 'khóa' trong mã mẫu của mình, có vẻ như bạn đang coi đối tượng là hàm băm, trong trường hợp đó, câu trả lời của bạn sẽ có ý nghĩa. Tất cả các khóa băm sẽ là các thuộc tính trong đối tượng và bạn tránh các thuộc tính bổ sung được đóng góp bởi nguyên mẫu.

Câu trả lời của John Resig rất toàn diện, nhưng tôi nghĩ nó không rõ ràng. Đặc biệt là khi nào nên sử dụng "'prop' trong obj".

Để kiểm tra các đối tượng đơn giản sử dụng: if (obj[x] !== undefined)

Nếu bạn không biết nó sử dụng loại đối tượng nào: if (obj.hasOwnProperty(x))

Tất cả các tùy chọn khác đều chậm hơn ..

Chi tiết

Đánh giá hiệu suất của 100.000.000 chu kỳ theo Nodejs cho 5 tùy chọn được đề xuất bởi những người khác ở đây:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== 'undefined'); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

Việc đánh giá cho chúng ta biết rằng trừ khi chúng ta đặc biệt muốn kiểm tra chuỗi nguyên mẫu của đối tượng cũng như chính đối tượng đó, chúng ta không nên sử dụng hình thức phổ biến: if (X in Obj)... Nó chậm hơn từ 2 đến 6 lần tùy theo trường hợp sử dụng

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

Tóm lại, nếu Obj của bạn không nhất thiết là một đối tượng đơn giản và bạn muốn tránh kiểm tra chuỗi nguyên mẫu của đối tượng và để đảm bảo x được sở hữu trực tiếp bởi Obj, hãy sử dụng 'if (obj.hasOwnProperty (x)) ...'.

Mặt khác, khi sử dụng một đối tượng đơn giản và không lo lắng về chuỗi nguyên mẫu của đối tượng, sử dụng if (typeof(obj[x]) !== 'undefined')...là cách an toàn và nhanh nhất.

Nếu bạn sử dụng một đối tượng đơn giản như một bảng băm và không bao giờ làm bất cứ điều gì khó chịu, tôi sẽ sử dụng if (obj[x])...vì tôi thấy nó dễ đọc hơn nhiều.

Chúc vui vẻ.

Đúng vậy :) Tôi nghĩ bạn cũng có thể làm việc Object.prototype.hasOwnProperty.call(x, 'key')đó cũng nên hoạt động nếu xcó một tài sản được gọi là hasOwnProperty:)

Nhưng đó là thử nghiệm cho các thuộc tính riêng. Nếu bạn muốn kiểm tra nếu nó có một tài sản cũng có thể được hít vào, bạn có thể sử dụng typeof x.foo != 'undefined'.

if (typeof x.key != "undefined") {

}

Bởi vì

if (x.key)

thất bại nếu x.keygiải quyết false(ví dụ, x.key = "").

Bạn cũng có thể sử dụng đối tượng ES6Reflect :

x = {'key': 1};
Reflect.has( x, 'key'); // returns true

Tài liệu về MDN cho Reflect.hascó thể được tìm thấy ở đây .

Reflect.has()Phương thức tĩnh hoạt động giống như toán tử in như là một hàm.

OK, có vẻ như tôi đã có câu trả lời đúng trừ khi bạn không muốn các thuộc tính được kế thừa:

if (x.hasOwnProperty('key'))

Dưới đây là một số tùy chọn khác để bao gồm các thuộc tính được kế thừa:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

Không làm điều này object.hasOwnProperty(key)), nó thực sự xấu vì các phương thức này có thể bị che khuất bởi các thuộc tính trên đối tượng được đề cập - xem xét { hasOwnProperty: false }- hoặc, đối tượng có thể là một đối tượng null (Object.create(null)).

Cách tốt nhất là làm Object.prototype.hasOwnProperty.call(object, key)hoặc:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
// ...
console.log(has.call(object, key));

Một cách tương đối đơn giản là sử dụng Object.keys. Điều này trả về một arraynghĩa là bạn có được tất cả các tính năng của một mảng.

var noInfo = {};
var info = {something: 'data'};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

Mặc dù chúng ta đang ở trong một thế giới có sự hỗ trợ trình duyệt tuyệt vời. Bởi vì câu hỏi này quá cũ nên tôi nghĩ tôi nên thêm câu hỏi này: Điều này an toàn khi sử dụng kể từ phiên bản JS v1.8.5

hasOwnProperty "có thể được sử dụng để xác định xem một đối tượng có thuộc tính được chỉ định là thuộc tính trực tiếp của đối tượng đó hay không , không giống như toán tử trong , phương thức này không kiểm tra chuỗi nguyên mẫu của đối tượng."

Vì vậy, rất có thể, đối với những gì dường như bởi câu hỏi của bạn, bạn không muốn sử dụng hasOwnProperty, điều này sẽ xác định xem thuộc tính có tồn tại như được gắn trực tiếp vào chính đối tượng hay không .

Nếu bạn muốn xác định xem thuộc tính có tồn tại trong chuỗi nguyên mẫu mà bạn muốn sử dụng không, như:

if( prop in object ){ // do something }

Tôi hi vọng cái này giúp được.

Với nguy cơ giảm tải lớn, đây là một lựa chọn khác cho một trường hợp cụ thể. :)

Nếu bạn muốn kiểm tra một thành viên trên một đối tượng và muốn biết liệu nó đã được đặt thành một cái gì đó ngoài:

• ''
• sai
• vô giá trị
• chưa xác định
• 0 ...

sau đó bạn có thể sử dụng:

var foo = {};
foo.bar = "Yes, this is a proper value!";
if (!!foo.bar) {
        // member is set, do something
}

Giải pháp ECMA Script 6 có phản ánh. Tạo trình bao bọc như:

/**
Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
*/
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === 'undefined' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   }
   return retVal;
}  // getSafeReflectArg

Có phương thức "hasOwnProperty" tồn tại trên đối tượng, nhưng không nên gọi phương thức này trực tiếp vì đôi khi có thể đối tượng là null hoặc một số thuộc tính tồn tại trên đối tượng như: { hasOwnProperty: false }

Vì vậy, cách tốt hơn sẽ là:

// good
var obj = {"bar": "here bar desc"}
console.log(Object.prototype.hasOwnProperty.call(obj, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(obj, "bar"));

Bạn có thể sử dụng các phương pháp sau đây-

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

Sự khác biệt giữa các cách tiếp cận sau đây như sau-

1. Trong cách tiếp cận thứ 1 và thứ 3, chúng tôi không chỉ tìm kiếm trong đối tượng mà cả chuỗi nguyên mẫu của nó. Nếu đối tượng không có tài sản, nhưng tài sản có mặt trong chuỗi nguyên mẫu của nó thì nó sẽ thành sự thật.

 var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log('b' in obj)
    console.log(Boolean(obj.b))

2. Cách tiếp cận thứ 2 sẽ chỉ kiểm tra các thuộc tính riêng của nó. Ví dụ -

var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log(obj.hasOwnProperty('b'))

3. Sự khác biệt giữa thứ 1 và thứ ba là nếu có một thuộc tính có giá trị không xác định thì cách tiếp cận thứ 3 sẽ sai trong khi đầu tiên sẽ cho đúng.

var obj = {
      b : undefined
    }
    console.log(Boolean(obj.b))
    console.log('b' in obj);

Bạn cần sử dụng phương pháp object.hasOwnProperty(property). Nó trả về true nếu đối tượng có thuộc tính và false nếu đối tượng không.

Nếu khóa bạn đang kiểm tra được lưu trữ trong một biến , bạn có thể kiểm tra nó như thế này:

x = {'key': 1};
y = 'key';
x[y];

Tại sao quá phức tạp mọi thứ khi bạn có thể làm:

var isProperty =  (objectname.keyname || "") ? true : false;

Đơn giản và rõ ràng cho hầu hết các trường hợp ...