JavaScript 객체 또는 배열에 특정 키가 있는지 어떻게 확인합니까?

키가 존재하지 않고 액세스하려고하면 false를 반환합니까? 아니면 오류를 던져?

정의되지 않은 검사는 키가 있는지 여부를 테스트하는 정확한 방법이 아닙니다. 키가 있지만 실제로 값이 있으면 undefined어떻게됩니까?

var obj = { key: undefined };
obj["key"] !== undefined // false, but the key exists!

대신 in연산자 를 사용해야합니다 .

"key" in obj // true, regardless of the actual value

키가 존재하지 않는지 확인하려면 괄호를 사용해야합니다.

!("key" in obj) // true if "key" doesn't exist in object
!"key" in obj   // ERROR!  Equivalent to "false in obj"

또는 상속 된 속성이 아닌 객체 인스턴스의 속성을 특별히 테스트하려면 hasOwnProperty다음을 사용하십시오 .

obj.hasOwnProperty("key") // true

있는 방법 사이의 성능 비교를 들어 in, hasOwnProperty키가 undefined,이 볼 벤치 마크

빠른 답변

JavaScript 객체 또는 배열에 특정 키가 있는지 어떻게 확인합니까? 키가 존재하지 않고 액세스하려고하면 false를 반환합니까? 아니면 오류를 던져?

(연관) 배열 스타일 또는 객체 스타일을 사용하여 누락 된 속성에 직접 액세스하면 정의되지 않은 값 이 반환됩니다 상수 됩니다.

느린하고 신뢰할 수 있는 연산자와 hasOwnProperty 방법

사람들이 이미 여기에서 언급했듯이 "정의되지 않은"상수와 연관된 속성을 가진 개체를 가질 수 있습니다.

 var bizzareObj = {valid_key:  undefined};

이 경우에는 hasOwnProperty 나 에 키가 정말이 있는지 알고 연산자를. 그러나 가격은 얼마입니까?

그래서 나는 당신에게 ...

에 연산자와 hasOwnProperty 는 Javascript에서 속성 설명자 메커니즘을 사용하는 "메소드"입니다 (Java에서 Java 리플렉션과 유사).

http://www.ecma-international.org/ecma-262/5.1/#sec-8.10

속성 설명자 유형은 명명 된 속성 속성의 조작 및 수정을 설명하는 데 사용됩니다. 속성 설명자 유형의 값은 각 필드의 이름이 속성 이름이고 해당 값이 8.6.1에 지정된 해당 속성 값인 명명 된 필드로 구성된 레코드입니다. 또한 모든 필드가 있거나 없을 수 있습니다.

반면에 객체 메소드 또는 키를 호출하면 Javascript [[Get]] 메커니즘이 사용됩니다. 훨씬 빠릅니다!

기준

http://jsperf.com/checking-if-a-key-exists-in-a-javascript-array

.

var result = "Impression" in array;

결과는

12,931,832 ±0.21% ops/sec      92% slower 

var result = array.hasOwnProperty("Impression")

결과는

16,021,758 ±0.45% ops/sec     91% slower

var result = array["Impression"] === undefined

결과는

168,270,439 ±0.13 ops/sec     0.02% slower 

var result = array.Impression  === undefined;

결과는

168,303,172 ±0.20%     fastest

편집 : 속성에 undefined값 을 할당하는 이유는 무엇입니까 ?

그 질문은 나를 당혹스럽게한다. Javascript에는 다음 null과 같은 문제를 피하기 위해 부재 객체에 대한 참조가 두 개 이상 undefined있습니다.

null는 객체 값의 의도적 인 부재 또는 단기적으로 확인 된 값 결여를 나타내는 기본 값입니다 . 한편, undefined알 수없는 값 (정의되지 않음)입니다. 적절한 값으로 나중에 사용할 특성이있는 경우 초기 순간에 특성 에 값이없는 것으로 확인 되므로 null대신 참조를 사용 하십시오 .undefined

비교:

var a = {1: null}; 
console.log(a[1] === undefined); // output: false. I know the value at position 1 of a[] is absent and this was by design, i.e.:  the value is defined. 
console.log(a[0] === undefined); // output: true. I cannot say anything about a[0] value. In this case, the key 0 was not in a[].

권하다

undefined값이있는 물체는 피하십시오 . 가능할 때마다 직접 확인하고 null속성 값을 초기화 하는 데 사용하십시오 . 그렇지 않으면 느린 in연산자 나 hasOwnProperty()방법을 사용하십시오 .

편집 : 2018 년 12 월 4 일-더 이상 관련이 없습니다.

사람들이 언급했듯이, 최신 버전의 Javascript 엔진 (firefox 제외)은 액세스 속성에 대한 접근 방식을 변경했습니다. 현재 구현은이 특별한 경우에 이전 구현보다 느리지 만 액세스 키와 객체의 차이는 무시할 수 있습니다.

반환 undefined됩니다.

var aa = {hello: "world"};
alert( aa["hello"] );      // popup box with "world"
alert( aa["goodbye"] );    // popup box with "undefined"

undefined특별한 상수 값입니다. 예를 들어

// note the three equal signs so that null won't be equal to undefined
if( aa["goodbye"] === undefined ) {
    // do something
}

이것은 아마도 누락 된 키를 확인하는 가장 좋은 방법입니다. 그러나 아래 주석에서 지적했듯이 이론적으로 실제 값을 원할 수도 있습니다 undefined. 나는 이것을 할 필요가 없었고 내가 왜 원했던 지 알 수없는 이유를 생각할 수는 없지만 완전성을 위해 in연산자를 사용할 수 있습니다.

// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
    // do something
}

허용 대답 을 참조 객체 . 배열 대신 in연산자 를 사용하여 키 대신 데이터를 찾으십시오.

("true" in ["true", "false"])
// -> false (Because the keys of the above Array are actually 0 and 1)

배열에서 기존 요소를 테스트하려면 : 항목이 JavaScript 배열인지 확인하는 가장 좋은 방법은 무엇입니까?

"key" in obj

배열 키와 매우 다른 객체 속성 값만 테스트 할 가능성이 있음

자바 스크립트 객체에 속성이 있는지 확인하는 세 가지 방법 :

1. !! obj.theProperty
   값을 bool로 변환합니다. 'false'값을 제외한 모든 값에 대해 TRUE를 반환합니다.
2. obj의 'theProperty'
   는 값에 관계없이 속성이 존재하면 true를 반환합니다 (비어 있음).
3. obj.hasOwnProperty ( 'theProperty')
   프로토 타입 체인을 확인하지 않습니다. (모든 객체에는 'toString'메서드가 있으므로 1과 2는 true를 반환하고 3은 false를 반환 할 수 있습니다.)

참고:

http://book.mixu.net/node/ch5.html

underscore.js 라이브러리를 사용하는 경우 객체 / 배열 작업이 간단 해집니다.

귀하의 경우 _.has 메소드를 사용할 수 있습니다. 예:

yourArray = {age: "10"}

_.has(yourArray, "age")

true를 반환

그러나,

_.has(yourArray, "invalidKey")

거짓을 돌려 준다

대답:

if ("key" in myObj)
{
    console.log("key exists!");
}
else
{
    console.log("key doesn't exist!");
}

설명:

in키가 객체에있는 경우 운영자는 확인합니다. 값이 정의되어 있지 않은지 확인한 경우 : if (myObj["key"] === 'undefined'), 값이 있는 객체에 키가있을 수 있으므로 문제가 발생할 수 있습니다 undefined.

따라서 먼저 in연산자를 사용하고 이미 알고있는 키 안에있는 값을 비교하는 것이 훨씬 좋습니다 .

여기에 매우 유용한 도우미 함수가 있습니다.

이것은 keyExists(key, search)객체 또는 배열 내에서 키를 쉽게 조회하는 데 사용할 수 있습니다!

찾으려는 키를 전달하고 찾으려는 obj (객체 또는 배열)를 검색하십시오.

function keyExists(key, search) {
        if (!search || (search.constructor !== Array && search.constructor !== Object)) {
            return false;
        }
        for (var i = 0; i < search.length; i++) {
            if (search[i] === key) {
                return true;
            }
        }
        return key in search;
    }

// How to use it:
// Searching for keys in Arrays
console.log(keyExists('apple', ['apple', 'banana', 'orange'])); // true
console.log(keyExists('fruit', ['apple', 'banana', 'orange'])); // false

// Searching for keys in Objects
console.log(keyExists('age', {'name': 'Bill', 'age': 29 })); // true
console.log(keyExists('title', {'name': 'Jason', 'age': 29 })); // false

꽤 안정적이었으며 브라우저 간 잘 작동합니다.

바닐라 js

yourObjName.hasOwnProperty(key) : true ? false;

es2015에서 객체에 속성이 하나 이상 있는지 확인하려는 경우

Object.keys(yourObjName).length : true ? false

ES6 솔루션

Array#some및 사용 Object.keys. 돌아올 것이다 사실 지정된 키가 개체 나에있는 경우 거짓 그렇지 않은 경우.

var obj = {foo: 'one', bar: 'two'};
    
function isKeyInObject(obj, key) {
    var res = Object.keys(obj).some(v => v == key);
    console.log(res);
}

isKeyInObject(obj, 'foo');
isKeyInObject(obj, 'something');

한 줄 예.

console.log(Object.keys({foo: 'one', bar: 'two'}).some(v => v == 'foo'));

우리는 사용할 수 있습니다- hasOwnProperty.call(obj, key);

underscore.js 방법 -

if(_.has(this.options, 'login')){
  //key 'login' exists in this.options 
}

_.has = function(obj, key) {
  return hasOwnProperty.call(obj, key);
};

확인하는 가장 쉬운 방법은

"key" in object

예를 들면 다음과 같습니다.

var obj = {
  a: 1,
  b: 2,
}
"a" in obj // true
"c" in obj // false

true 값을 반환 하면 객체에 키가 있음을 의미합니다.

이있는 사람들을 위해 lodash자신의 프로젝트에 포함 된
lodash의이 _.get의 "깊은"키를 얻기 위해 시도하는 방법은 :

객체의 경로에서 값을 가져옵니다. 해석 된 값이 정의되지 않은 경우 defaultValue가 그 자리에 리턴됩니다.

var object = { 'a': [{ 'b': { 'c': 3 } }] };

console.log(
  _.get(object, 'a[0].b.c'),           // => 3
  _.get(object, ['a', '0', 'b', 'c']), // => 3
  _.get(object, 'a.b.c'),              // => undefined 
  _.get(object, 'a.b.c', 'default')    // => 'default'
)

<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

이렇게하면 해당 키 가 정의되어 있는지 확인하지만 깊이 가 정의 되지 않은 경우 프로그램 흐름에 해를 끼칠 수있는 오류가 발생하지 않습니다.

키가 있는지 반드시 확인하는 것은 아니지만 값의 진실성을 확인합니다. 어느 undefined와 null가을에서.

Boolean(obj.foo)

이 솔루션은 typescript를 사용하고 문자열을 사용 'foo' in obj하거나 obj.hasOwnProperty('foo') 키가 있는지 여부를 확인 하기 때문에 나에게 가장 효과적입니다 .

객체에서 임의의 깊이의 키를 확인하고 잘못된 값을 설명하려면 유틸리티 기능에 대해 다음 줄을 고려하십시오.

var keyExistsOn = (o, k) => k.split(".").reduce((a, c) => a.hasOwnProperty(c) ? a[c] || 1 : false, Object.assign({}, o)) === false ? false : true;

결과

var obj = {
    test: "",
    locals: {
        test: "",
        test2: false,
        test3: NaN,
        test4: 0,
        test5: undefined,
        auth: {
            user: "hw"
        }
    }
}

keyExistsOn(obj, "")
> false
keyExistsOn(obj, "locals.test")
> true
keyExistsOn(obj, "locals.test2")
> true
keyExistsOn(obj, "locals.test3")
> true
keyExistsOn(obj, "locals.test4")
> true
keyExistsOn(obj, "locals.test5")
> true
keyExistsOn(obj, "sdsdf")
false
keyExistsOn(obj, "sdsdf.rtsd")
false
keyExistsOn(obj, "sdsdf.234d")
false
keyExistsOn(obj, "2134.sdsdf.234d")
false
keyExistsOn(obj, "locals")
true
keyExistsOn(obj, "locals.")
false
keyExistsOn(obj, "locals.auth")
true
keyExistsOn(obj, "locals.autht")
false
keyExistsOn(obj, "locals.auth.")
false
keyExistsOn(obj, "locals.auth.user")
true
keyExistsOn(obj, "locals.auth.userr")
false
keyExistsOn(obj, "locals.auth.user.")
false
keyExistsOn(obj, "locals.auth.user")
true

이 NPM 패키지도 참조하십시오 : https://www.npmjs.com/package/has-deep-value

const object1 = {
  a: 'something',
  b: 'something',
  c: 'something'
};

const key = 's';

// Object.keys(object1) will return array of the object keys ['a', 'b', 'c']

Object.keys(object1).indexOf(key) === -1 ? 'the key is not there' : 'yep the key is exist';

'배열'세계에서는 인덱스를 일종의 키로 볼 수 있습니다. 놀랍게도 in연산자 (객체에 적합한 선택)는 배열에서도 작동합니다. 존재하지 않는 키의 반환 값은undefined

let arr = ["a","b","c"]; // we have indexes: 0,1,2
delete arr[1];           // set 'empty' at index 1
arr.pop();               // remove last item

console.log(0 in arr,  arr[0]);
console.log(1 in arr,  arr[1]);
console.log(2 in arr,  arr[2]);

yourArray.indexOf (yourArrayKeyName)> -1

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple') > -1

진실

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple1') > -1

그릇된

이 예제는 다른 방법들 사이의 차이점을 보여줄 수 있습니다. 귀하의 요구에 맞는 것을 선택하는 데 도움이되기를 바랍니다.

// Lets create object `a` using create function `A`
function A(){};
A.prototype.onProtDef=2;
A.prototype.onProtUndef=undefined;
var a=new A();
a.ownProp = 3;
a.ownPropUndef = undefined;

// Let's try different methods:

a.onProtDef; // 2
a.onProtUndef; // undefined
a.ownProp; // 3
a.ownPropUndef; // undefined
a.whatEver; // undefined
a.valueOf; // ƒ valueOf() { [native code] }

a.hasOwnProperty('onProtDef'); // false
a.hasOwnProperty('onProtUndef'); // false
a.hasOwnProperty('ownProp'); // true
a.hasOwnProperty('ownPropUndef'); // true
a.hasOwnProperty('whatEver'); // false
a.hasOwnProperty('valueOf'); // false

'onProtDef' in a; // true
'onProtUndef' in a; // true
'ownProp' in a; // true
'ownPropUndef' in a; // true
'whatEver' in a; // false
'valueOf' in a; // true (on the prototype chain - Object.valueOf)

Object.keys(a); // ["ownProp", "ownPropUndef"]

JavaScript Destructuring을 사용한 새로운 멋진 솔루션 :

let obj = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3",
};

let {key1, key2, key3, key4} = obj;

// key1 = "value1"
// key2 = "value2"
// key3 = "value3"
// key4 = undefined

// Can easily use `if` here on key4
if(!key4) { console.log("key not present"); } // Key not present

JavaScript Destructuring의 다른 사용을 확인하십시오