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

可以使用 Array 方法 .some:

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

试试:

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

你可以试试这个:

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

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

例子一

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


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

if( myObj.hasOwnProperty('key') && myObj['key'] === value ){
...
}

您可以将 Object 的值转换为数组并测试是否存在字符串。它假设 Object 不是嵌套的，并且字符串是完全匹配的:

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

使用 for...in循环:

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

我用所有这些例子做了一个测试，并在 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

你可以使用 Value ():

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

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

Value ()方法返回一个数组(分配给 getValuesOfObject) ，其中包含给定对象的(obj)自己的可枚举属性值。使用 for循环迭代该数组以检索每个值(getValuesfrom Object 中的值) ，并返回一个 Boolean ()函数以确定表达式(“ text1”是循环数组中的值)是否为真。

对于一句俏皮话，我会说:

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

最短的 ES6 + 一个班轮:

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

下面给出了这个问题的简单答案。

这是有效的，因为每个 JavaScript 类型上都有一个 “构造函数”属性 原型机”。

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




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

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

你可以试试这个

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


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


findSpecificStr(obj, 'test1');

在新版本中，如果 ecma 脚本现在我们可以通过 ?.操作检查 vslue. 。

在对象或嵌套对象中检查值是如此简单和容易

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

谢谢

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

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)

if (Object.values(obj).includes('test1')){
return true
}

_.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']));

产出: 没错 没错 假的

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

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