ฉันจะตรวจสอบว่ามีคีย์เฉพาะอยู่ในวัตถุหรืออาร์เรย์ JavaScript ได้อย่างไร

หากไม่มีรหัสและฉันพยายามเข้าถึงรหัสจะส่งคืนเท็จหรือไม่ หรือโยนข้อผิดพลาด?

การตรวจสอบสำหรับ undefined-ness ไม่ใช่วิธีที่ถูกต้องในการทดสอบว่ามีคีย์หรือไม่ เกิดอะไรขึ้นถ้าคีย์ที่มีอยู่ แต่ค่าที่เป็นจริง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 ได้อย่างไร หากไม่มีรหัสและฉันพยายามเข้าถึงมันจะส่งคืนรหัสเท็จหรือไม่ หรือโยนข้อผิดพลาด?

การเข้าถึงคุณสมบัติที่ขาดหายไปโดยตรงโดยใช้สไตล์อาร์เรย์ (เชื่อมโยง) หรือสไตล์วัตถุจะส่งคืนค่าคงที่ที่ไม่ได้กำหนด

ช้าและเชื่อถือได้ในผู้ประกอบการและวิธีhasOwnProperty

ในฐานะที่เป็นคนได้กล่าวถึงแล้วที่นี่คุณสามารถมีวัตถุที่มีคุณสมบัติที่เกี่ยวข้องกับค่าคงที่ "ไม่ได้กำหนด"

 var bizzareObj = {valid_key:  undefined};

ในกรณีนั้นคุณจะต้องใช้hasOwnPropertyหรือในโอเปอเรเตอร์เพื่อทราบว่ากุญแจนั้นอยู่ที่นั่นหรือไม่ แต่ราคาเท่าไหร่

ดังนั้นฉันบอกคุณ ...

ในโอเปอเรเตอร์และhasOwnPropertyคือ "เมธอด" ที่ใช้กลไกตัวอธิบายคุณสมบัติใน Javascript (คล้ายกับการสะท้อนของ 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 มีอย่างน้อยสองอ้างอิงสำหรับวัตถุที่ขาดหลีกเลี่ยงปัญหาเช่นนี้และnullundefined

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()วิธีการ

แก้ไข: 12/04/2018 - ไม่เกี่ยวข้องอีกต่อไป

ตามที่ผู้คนได้แสดงความคิดเห็นเอ็นจิ้น 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โอเปอเรเตอร์บนArrayเพื่อค้นหาข้อมูลแทนที่จะใช้คีย์:

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

ในการทดสอบองค์ประกอบที่มีอยู่ใน Array: วิธีที่ดีที่สุดในการค้นหาว่ารายการนั้นอยู่ในอาร์เรย์ JavaScript หรือไม่

"key" in obj

มีแนวโน้มว่าจะทดสอบเฉพาะค่าแอตทริบิวต์ของวัตถุที่แตกต่างจากคีย์อาร์เรย์

สามวิธีในการตรวจสอบว่ามีคุณสมบัติอยู่ในวัตถุจาวาสคริปต์หรือไม่:

1. !!obj.theProperty
   จะแปลงค่าเป็นบูล ส่งคืนtrueสำหรับทั้งหมดยกเว้นfalseค่า
2. ' theProperty' ใน obj
   จะคืนค่าเป็นจริงถ้าคุณสมบัติมีอยู่ไม่ว่าจะเป็นค่าใด (ว่างเปล่า)
3. obj.hasOwnProperty('theProperty')
   ไม่ตรวจสอบสายโซ่ต้นแบบ (เนื่องจากวัตถุทั้งหมดมีtoStringวิธีการ 1 และ 2 จะคืนค่าจริงเมื่อมันในขณะที่ 3 สามารถกลับเท็จบนมัน)

อ้างอิง:

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

หากคุณกำลังใช้ไลบรารีunderscore.jsการดำเนินการกับวัตถุ / อาร์เรย์จะกลายเป็นเรื่องง่าย

ในกรณีของคุณวิธี _.has สามารถนำมาใช้ ตัวอย่าง:

yourArray = {age: "10"}

_.has(yourArray, "age")

ผลตอบแทนจริง

แต่,

_.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

มันค่อนข้างน่าเชื่อถือและใช้งานได้ดีกับเบราว์เซอร์

Vanila 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

ส่งคืนค่าตามจริงแสดงว่ามีคีย์ในวัตถุ

สำหรับผู้ที่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') เพื่อตรวจสอบว่ามีคีย์อยู่หรือไม่ไม่ได้ให้ระบบ Intellisense ให้ฉัน

หากคุณต้องการตรวจสอบคีย์ใด ๆ ที่ระดับความลึกใด ๆ บนวัตถุและบัญชีสำหรับค่าที่ไม่ถูกต้องให้พิจารณาบรรทัดนี้สำหรับฟังก์ชันยูทิลิตี้:

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 :

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