如何使用 JavaScript 检查对象中是否存在值

Question

我在 JavaScript 中有一个对象：

var obj = {
   "a": "test1",
   "b": "test2"
}

如何检查 test1 是否作为值存在于对象中？

Answer 1

您可以将对象的值转换为数组并测试字符串是否存在。它假设对象没有嵌套并且字符串是完全匹配的：

var obj = { a: 'test1', b: 'test2' };
if (Object.values(obj).indexOf('test1') > -1) {
   console.log('has test1');
}

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/values

Answer 2

最短的ES6+一班线：

let exists = Object.values(obj).includes("test1");

Answer 3

可以使用数组方法

.some

:

var exists = Object.keys(obj).some(function(k) {
    return obj[k] === "test1";
});

Answer 4

尝试：

var obj = {
   "a": "test1",
   "b": "test2"
};

Object.keys(obj).forEach(function(key) {
  if (obj[key] == 'test1') {
    alert('exists');
  }
});

或者

var obj = {
   "a": "test1",
   "b": "test2"
};

var found = Object.keys(obj).filter(function(key) {
  return obj[key] === 'test1';
});

if (found.length) {
   alert('exists');
}

这对于这些值的

NaN

和

-0

不起作用。您可以使用（而不是

===

）ECMAScript 6 中的新增功能：

 Object.is(obj[key], value);

使用现代浏览器，您还可以使用：

var obj = {
   "a": "test1",
   "b": "test2"
};

if (Object.values(obj).includes('test1')) {
  alert('exists');
}

Answer 5

使用

for...in

循环：

for (let k in obj) {
    if (obj[k] === "test1") {
        return true;
    }
}

Answer 6

您可以使用 Object.values():

Object.values()
方法返回给定对象自己的数组可枚举属性值，其顺序与提供的顺序相同
for...in
循环（区别在于 for-in 循环枚举原型链中的属性也是如此）。

然后使用 indexOf() 方法：

indexOf()
方法返回给定的第一个索引可以在数组中找到元素，如果不存在则为 -1。

例如：

Object.values(obj).indexOf("test") >= 0

更详细的示例如下：

var obj = {
  "a": "test1",
  "b": "test2"
}


console.log(Object.values(obj).indexOf("test1")); // 0
console.log(Object.values(obj).indexOf("test2")); // 1

console.log(Object.values(obj).indexOf("test1") >= 0); // true
console.log(Object.values(obj).indexOf("test2") >= 0); // true 

console.log(Object.values(obj).indexOf("test10")); // -1
console.log(Object.values(obj).indexOf("test10") >= 0); // false

Answer 7

对于一句话，我会说：

exist = Object.values(obj).includes("test1");
console.log(exist);

Answer 8

我对所有这些示例进行了测试，并在 Node.js v8.11.2 中运行了它。将此作为指南来选择您的最佳选择。

let i, tt;
    const obj = { a: 'test1', b: 'test2', c: 'test3', d: 'test4', e: 'test5', f: 'test6' };

console.time("test1")
i = 0;
for( ; i<1000000; i=i+1) {
  if (Object.values(obj).indexOf('test4') > -1) {
    tt = true;
  }
}
console.timeEnd("test1")

console.time("test1.1")
i = 0;
for( ; i<1000000 ; i=i+1) {
  if (~Object.values(obj).indexOf('test4')) {
    tt = true;
  }
}
console.timeEnd("test1.1")

console.time("test2")
i = 0;
for( ; i<1000000; i=i+1) {
  if (Object.values(obj).includes('test4')) {
    tt = true;
  }
}
console.timeEnd("test2")


console.time("test3")
i = 0;
for( ; i<1000000 ; i=i+1) {
  for(const item in obj) {
    if(obj[item] == 'test4') {
      tt = true;
      break;
    }
  }
}
console.timeEnd("test3")

console.time("test3.1")
i = 0;
for( ; i<1000000; i=i+1) {
  for(const [item, value] in obj) {
    if(value == 'test4') {
      tt = true;
      break;
    }
  }
}
console.timeEnd("test3.1")


console.time("test4")
i = 0;
for( ; i<1000000; i=i+1) {
  tt = Object.values(obj).some((val, val2) => {
    return val == "test4"
  });
}
console.timeEnd("test4")

console.time("test5")
i = 0;
for( ; i<1000000; i=i+1) {
  const arr = Object.keys(obj);
  const len = arr.length;
  let i2 = 0;
  for( ; i2<len ; i2=i2+1) {
    if(obj[arr[i2]] == "test4") {
      tt = true;
      break;
    }
  }
}
console.timeEnd("test5")

我的服务器上的输出

test1:   272.325 ms
test1.1: 246.316 ms
test2:   251.98 0ms
test3:    73.284 ms
test3.1: 102.029 ms
test4:   339.299 ms
test5:    85.527 ms

Answer 9

你可以试试这个

var obj = {
  "a": "test1",
  "b": "test2"
};

const findSpecificStr = (obj, str) => {
  return Object.values(obj).includes(str);
}

findSpecificStr(obj, 'test1');

Answer 10

你可以试试这个：

function checkIfExistingValue(obj, key, value) {
    return obj.hasOwnProperty(key) && obj[key] === value;
}
var test = [{name : "jack", sex: F}, {name: "joe", sex: M}]
console.log(test.some(function(person) { return checkIfExistingValue(person, "name", "jack"); }));

Answer 11

在新版本中，如果 ecma 脚本现在我们可以通过

?.

操作检查 vslues..

检查对象或嵌套或对象中的值非常简单和容易

var obj = {
   "a": "test1",
   "b": "test2"
}

if(obj?.a) return "i got the value"

同样，在 Javascript 中最常用的原始类型是 Object

我们也可以使用这个数组、函数等

aFunc = () => { return "gotcha"; }

aFunc?.() // returns gotcha

myArray = [1,2,3]

myArray?.[3] // returns undefined

谢谢

Answer 12

使用 Object.keys() 查找对象中存在值的最佳方法

obj = {
 "India" : {
 "Karnataka" : ["Bangalore", "Mysore"],
 "Maharashtra" : ["Mumbai", "Pune"]
 },
 "USA" : {
 "Texas" : ["Dallas", "Houston"],
 "IL" : ["Chicago", "Aurora", "Pune"]
 }
}

function nameCity(e){
    var finalAns = []
    var ans = [];
    ans = Object.keys(e).forEach((a)=>{
        for(var c in e[a]){
            e[a][c].forEach(v=>{
                if(v === "Pune"){
                    finalAns.push(c)
                }
            })

        }
    })
    console.log(finalAns)
}


nameCity(obj)

Answer 13

ES2017 引入了一种名为 Object.values() 的新方法，它允许您返回对象自己的可枚举属性值的数组。

您可以执行此操作来检查该值是否存在于对象值中：

let found = Object.values(africanCountries).includes('Nigeria');
if (found) {
     // code
}

您还可以检查它是否存在于Object Keys中：

let found = Object.keys(africanCountries).includes('Nigeria');
if (found) {
     // code
}

Answer 14

getValue = function (object, key) {
    return key.split(".").reduce(function (obj, val) {
        return (typeof obj == "undefined" || obj === null || obj === "") ? obj : (_.isString(obj[val]) ? obj[val].trim() : obj[val]);}, object);
};

var obj = {
   "a": "test1",
   "b": "test2"
};

函数调用：

 getValue(obj, "a");

Answer 15

var obj = {"a": "test1", "b": "test2"};
var getValuesOfObject = Object.values(obj)
for(index = 0; index < getValuesOfObject.length; index++){
    return Boolean(getValuesOfObject[index] === "test1")
}

Object.values() 方法返回一个数组（分配给 getValuesOfObject），其中包含给定对象 (obj) 自己的可枚举属性值。使用

for

循环迭代该数组以检索每个值（getValuesfromObject 中的值）并返回 Boolean() 函数以查明表达式（“text1”是循环数组中的值）是否为 true。

Answer 16

对于复杂的结构，我是这样做的：

const obj = {
    test: [{t: 't'}, {t1: 't1'}, {t2: 't2'}],
  rest: [{r: 'r'}, {r1: 'r1'}, {r2: 'r2'}]
}

console.log(JSON.stringify(obj).includes(JSON.stringify({r1: 'r1'}))) // returns true
console.log(JSON.stringify(obj).includes(JSON.stringify({r1: 'r2'}))) // returns false

Answer 17

请参阅文档：https://developer.mozilla.org/enUS/docs/Web/JavaScript/Reference/Global_Objects/Object/values

Object.values

返回一个数组，因此任何数组操作（无论是

array.includes

、

array.some

、

indexOF

）都会让您检查该值是否存在。

Answer 18

检查javascript中每个对象键中是否存在值并想要返回该对象。

let arr = [{
    firstname: "test1",
    middlename: "test2",
    surname: "test3",
    age:20
},
{
    firstname: "test4",
    middlename: "test5",
    surname: "test6",
    age:25
},
{
    firstname: "test7",
    middlename: "test2",
    surname: "test8",
    age:30
}];

let filteredObjects = arr.filter((item) => Object.keys(item).some(key => item[key] === "test2"));

这将通过比较每个对象中的每个密钥对来返回对象。

答案：

[{
    firstname: "test1",
    middlename: "test2",
    surname: "test3",
    age:20
},
{
    firstname: "test7",
    middlename: "test2",
    surname: "test8",
    age:30
}]

希望这对您有帮助！

Answer 19

检查

in

const car = { make: 'Honda', model: 'Accord', year: 1998 };

console.log('make' in car);
// Expected output: true

delete car.make;
if ('make' in car === false) {
  car.make = 'Suzuki';
}

console.log(car.make);
// Expected output: "Suzuki"

来源https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in

Answer 20

_.has()

方法用于检查路径是否是对象的直接属性。如果路径存在则返回 true，否则返回 false。

var object = { 'a': { 'b': 2 } };
console.log(_.has(object, 'a.b')); 
console.log(_.has(object, ['a','b'])); 
console.log(_.has(object, ['a','b','c']));

输出：真的真的假

Answer 21

下面给出了简单的答案。

这是有效的，因为每个 JavaScript 类型都有一个 “constructor” 属性 prototype”。

let array = []
array.constructor === Array
// => true


let data = {}
data.constructor === Object
// => true

Answer 22

这应该是一个简单的检查。

示例1

var myObj = {"a": "test1"}

if(myObj.a == "test1") {
    alert("test1 exists!");
}

如何使用 JavaScript 检查对象中是否存在值

问题描述投票：0回答：22

22个回答

最新问题

如何使用 JavaScript 检查对象中是否存在值

问题描述 投票：0回答：22

22个回答

最新问题

问题描述投票：0回答：22