JavaScriptでオブジェクトに特定のプロパティがあるかどうかを確認するにはどうすればよいですか？

JavaScriptでオブジェクトに特定のプロパティがあるかどうかを確認するにはどうすればよいですか？

検討してください：

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

それが最善の方法ですか？

私は与えられた答えに本当に困惑しています-それらのほとんどはまったくまったく間違っています。もちろん、未定義、null、またはfalseの値を持つオブジェクトプロパティを持つことができます。したがって、プロパティチェックを単純に減らすtypeof this[property]か、さらに悪い場合にx.keyは、完全に誤解を招く結果をもたらします。

それはあなたが探しているものに依存します。オブジェクトにプロパティが物理的に含まれているかどうかを知りたい場合（そして、プロトタイプチェーンのどこかから来ていない場合）object.hasOwnPropertyは、その方法です。最新のブラウザはすべてそれをサポートしています。（古いバージョンのSafari-2.0.1以前では欠けていましたが、これらのバージョンのブラウザーはめったに使用されません。）

あなたが探しているものがオブジェクトに反復可能なプロパティがある場合（オブジェクトのプロパティを反復すると表示されます）、次のprop in objectようにします：希望する効果が得られます。

使用することhasOwnPropertyはおそらくあなたが望んでいることであり、フォールバック方法が必要かもしれないことを考慮して、私はあなたに次の解決策を提示します：

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 );
    }
}

上記は動作するクロスブラウザのソリューションでhasOwnPropertyあり、1つの注意点があります。同じプロパティがプロトタイプとインスタンスにある場合を区別することはできません。単にプロトタイプからのものであると想定しているだけです。状況に応じて、より寛大または厳格に変更することもできますが、少なくともこれはより役立つはずです。

とUnderscore.jsまたは（より良いです）lodash：

_.has(x, 'key');

これはを呼び出しますがObject.prototype.hasOwnProperty、（a）タイプの方が短く、（b）「安全な参照」を使用しますhasOwnProperty（つまり、hasOwnProperty上書きされても機能します）。

特に、lodashは次の_.hasように定義します。

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

どう？

var x = {'key': 1};

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

注意：以下は、strictモードのおかげで、現在ではほとんど使用されていませんhasOwnProperty。正しい解決策は、strictモードを使用し、を使用してプロパティの存在を確認することですobj.hasOwnProperty。この回答は、少なくとも広く実装されているのと同じくらい、これらの両方に先行しています（そうです、それは古いです）。歴史的なメモとして次をとってください。

undefined（残念ながら）そうではないことを覚えておいてくださいあなたがstrictモードを使用していない場合はJavaScriptで予約語。したがって、誰か（明らかに他の誰か）がコードを再定義してコードを破壊するという大胆なアイデアを持つ可能性があります。

したがって、より堅牢な方法は次のとおりです。

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

反対に、この方法ははるかに冗長であり、速度も遅くなります。：-/

一般的な代替策は、それundefinedが実際に未定義であることを確認することです。たとえばundefined、値が渡されないと呼ばれる追加のパラメーターを受け入れる関数にコードを配置します。値が渡されないようにするには、すぐに自分で呼び出すことができます。例：

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

if (x.key !== undefined)

アーミン・ロナッチャーはすでに私を打ち負かしているようですが、

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!');
}

Konrad RudolphとArmin Ronacherが指摘したように、より安全ですが遅いソリューションがは次のようになります。

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

in演算子を使用して、プロパティがオブジェクトに存在するかどうかを確認できます。

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

ループを使用してオブジェクトのすべてのプロパティをfor - inループし、特定のプロパティを確認することもできます。

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

列挙できないプロパティはfor-inループに表示されないため、このオブジェクトプロパティが列挙可能かどうかを検討する必要があります。また、列挙可能なプロパティがプロトタイプの列挙できないプロパティをシャドウしている場合、Internet Explorer 8には表示されません。以前。

列挙可能かどうかにかかわらず、すべてのインスタンスプロパティのリストが必要な場合は、

Object.getOwnPropertyNames(x);

これは、オブジェクトに存在するすべてのプロパティの名前の配列を返します。

最後に、typeof演算子を使用して、オブジェクトプロパティのデータ型を直接確認できます。

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

プロパティがオブジェクトに存在しない場合、文字列undefinedを返します。それ以外の場合は、適切なプロパティタイプを返します。ただし、これは、オブジェクトにプロパティがあるかどうかを確認する有効な方法とは限らないことに注意してください。プロパティが未定義に設定されている場合があるためです。typeof x.keyでも、キーはまだオブジェクト内）。

更新：未定義のJavaScriptプロパティと比較することで、プロパティが存在するかどうかを確認できます

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

キーが特にundefinedxオブジェクトに設定されていない限り、これは機能するはずです

ここでいくつかの混乱を切り抜けましょう。最初に、hasOwnPropertyすでに存在すると仮定して単純化しましょう。これは、現在使用されているブラウザの大多数に当てはまります。

hasOwnProperty渡された属性名がオブジェクトに追加されている場合はtrueを返します。これは、割り当てられている実際の値とは完全に独立しています undefined。

したがって：

var o = {}
o.x = undefined

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

しかしながら：

var o = {}

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

問題は、プロトタイプチェーンのオブジェクトが未定義の値を持つ属性を持っているときに何が起こるかです。hasOwnPropertyそれについては偽であり、そうです!== undefined。まだ、for..inそれを列挙にリストします。

要点は__prototype__、特定の識別子がオブジェクトまたはそのプロトタイプチェーン内の何にもアタッチされていないことを特定するためのクロスブラウザーの方法がないことです（Internet Explorerはを公開していません）。

プロパティを検索する場合は、「NO」。あなたが欲しい：

if ('prop' in obj) { }

一般に、プロパティがプロトタイプまたはオブジェクトに由来するかどうかを気にする必要はありません。

ただし、サンプルコードでは「キー」を使用したため、オブジェクトをハッシュとして処理しているように見えます。その場合、答えは理にかなっています。すべてのハッシュキーはオブジェクトのプロパティであり、プロトタイプによって提供される余分なプロパティを回避します。

ジョン・レジグの答えは非常に包括的でしたが、私はそれが明確ではないと思いました。特にobjで「 'prop'」を使用する場合。

単純なオブジェクトをテストするには、以下を使用します。 if (obj[x] !== undefined)

どのオブジェクトタイプかわからない場合は、次のように使用します。 if (obj.hasOwnProperty(x))

他のすべてのオプションは遅くなります。

詳細

Nodejsでの100,000,000サイクルのパフォーマンス評価と、ここで他の人が提案する5つのオプション：

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)); }

評価により、オブジェクトのプロトタイプチェーンとオブジェクト自体を具体的に確認したくない場合を除き、一般的な形式は使用しないでください。使用 if (X in Obj)... 例によっては、2〜6倍遅くなります

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

結論として、Objが必ずしも単純なオブジェクトではなく、オブジェクトのプロトタイプチェーンのチェックを避け、xがObjによって直接所有されていることを確認する場合は、 'if（obj.hasOwnProperty（x））...'を使用します。

それ以外の場合は、単純なオブジェクトを使用していて、オブジェクトのプロトタイプチェーンを気にしない場合if (typeof(obj[x]) !== 'undefined')...は、使用するのが最も安全で最速の方法です。

単純なオブジェクトをハッシュテーブルとして使用し、変なことをしない場合は、if (obj[x])...はるかに読みやすくなるので使用します。

楽しんで。

はい、それは:)と呼ばれるプロパティがObject.prototype.hasOwnProperty.call(x, 'key')あればうまくいくはずですが、あなたもできると思います:)xhasOwnProperty

しかし、それは自身のプロパティをテストします。継承される可能性のあるプロパティがあるかどうかを確認する場合は、を使用できますtypeof x.foo != 'undefined'。

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

}

なぜなら

if (x.key)

x.key解決する場合は失敗しますfalse（たとえば、x.key = ""）。

ES6 Reflectオブジェクトを使用することもできます。

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

以下のためのMDN上のドキュメントをReflect.has見つけることができるここに。

static Reflect.has()メソッドは、in演算子のように機能します。

OK、継承されたプロパティが必要でない限り、私は正しい答えを持っていたようです：

if (x.hasOwnProperty('key'))

継承されたプロパティを含めるためのその他のオプションは次のとおりです。

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

if (x.key !== undefined)

こんなことしないで object.hasOwnProperty(key))これらのメソッドは問題のオブジェクトのプロパティによって隠されている可能性があるため、考慮してください。{ hasOwnProperty: false }または、オブジェクトがnullオブジェクトである可能性があります。(Object.create(null))。

最善の方法は、以下を実行することですObject.prototype.hasOwnProperty.call(object, key)。

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));

別の比較的簡単な方法は、を使用することObject.keysです。これは、array配列のすべての機能を取得することを意味するを返します。

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

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

私たちは素晴らしいブラウザサポートのある世界にいますが。この質問はとても古いので、私はこれを追加したいと思いました：これはJS v1.8.5から安全に使用できます

hasOwnProperty " in演算子とは異なり、オブジェクトにそのオブジェクトの直接プロパティとして指定されたプロパティがあるかどうかを判断するために使用できます。、このメソッドはオブジェクトのプロトタイプチェーンをチェックダウンしません。」

したがって、おそらくあなたの質問のように、オブジェクト自体に直接接続されているプロパティが存在するかどうかを判断するhasOwnPropertyを使用したくないでしょう。

主に使用したいプロトタイプチェーンにプロパティが存在するかどうかを確認するには、次のようにします。

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

これがお役に立てば幸いです。

大規模な反対投票のリスクがあるため、ここに特定のケースのための別のオプションがあります。:)

オブジェクトのメンバーをテストし、それが以下以外に設定されているかどうかを知りたい場合：

• 」
• 偽
• ヌル
• 未定義
• 0 ...

それからあなたは使うことができます：

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

リフレクトを備えたECMAスクリプト6ソリューション。次のようなラッパーを作成します。

/**
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

オブジェクトには「hasOwnProperty」メソッドが存在しますが、オブジェクトがnullであるか、次のようなオブジェクトにプロパティが存在する可能性があるため、このメソッドを直接呼び出すことはお勧めしません。 { hasOwnProperty: false }

だからより良い方法は：

// 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"));

次のアプローチを使用できます-

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

次のアプローチの違いは次のとおりです-

1. 1番目と3番目のアプローチでは、オブジェクトを検索するだけでなく、プロトタイプチェーンも検索します。オブジェクトにプロパティがないが、そのプロトタイプチェーンにプロパティが存在する場合は、trueになります。

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

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

2. 2番目のアプローチでは、独自のプロパティのみをチェックします。例-

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

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

3. 1番目と3番目の違いは、未定義の値を持つプロパティがある場合、3番目のアプローチは最初にtrueを与える一方でfalseを与えることになります。

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

メソッドを使用する必要がありますobject.hasOwnProperty(property)。オブジェクトにプロパティがある場合はtrueを返し、オブジェクトがない場合はfalseを返します。

チェックするキーが変数に格納されている場合は、次のようにチェックできます。

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

できるのになぜ複雑すぎるのか：

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

ほとんどの場合、シンプルで明確です...