JavaScript kullanarak bir nesnede bir değer olup olmadığını kontrol etme

JavaScript'te bir nesnem var:

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

Test1'in nesnede bir değer olarak var olup olmadığını nasıl kontrol ederim?

Bir Object'in değerlerini bir diziye dönüştürebilir ve bir dizenin mevcut olup olmadığını test edebilirsiniz. Object'in iç içe olmadığını ve dizenin tam olarak eşleştiğini varsayar:

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

Array yöntemini kullanabilirsiniz .some:

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

Deneyin:

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

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

Veya

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

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

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

Bu için çalışmaz NaNve -0bu değerler için. ===ECMAScript 6'daki yeniliklerin yerine kullanabilirsiniz :

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

Modern tarayıcılarla şunları da kullanabilirsiniz:

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

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

Bir for...indöngü kullanın :

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

En kısa ES6 + tek astar:

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

Object.values ​​() kullanabilirsiniz :

Object.values()Yöntem tarafından sağlanan ile aynı sırada, belirli bir nesnenin kendi numaralandırılabilir özellik değerleri bir dizi döner for...in(fark, bir hazır prototip zincirinde döngü sıralar özellikleri de) döngü.

ve sonra indexOf () yöntemini kullanın:

indexOf()Yöntem, belirli bir elemanı dizisinde bulunan, ya da hangi -1 mevcut değilse, birinci indeks döndürür.

Örneğin:

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

Daha ayrıntılı bir örnek aşağıdadır:

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

Tüm bu örneklerle bir test yaptım ve bunu Node.js v8.11.2'de çalıştırdım . En iyi seçiminizi seçmek için bunu bir kılavuz olarak alın.

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

Sunucumdaki çıktı

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

Tek hat için şunu söyleyebilirim:

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

Bunu deneyebilirsiniz:

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

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

İşlev adı:

 getValue(obj, "a");

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 ​​() yöntemi, verilen nesnenin (obj) kendi numaralandırılabilir özellik değerlerini içeren bir dizi (getValuesOfObject'e atanmış) döndürdü. Dizi, forher bir değeri (getValuesfromObject içindeki değerler) almak için döngü kullanılarak yinelenmiştir ve ifadenin ("metin1" döngü dizisindeki bir değer olup olmadığını) bulmak için bir Boolean () işlevi döndürür.

bunu deneyebilirsin

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

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

findSpecificStr(obj, 'test1');

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

Bunun basit cevabı aşağıda verilmiştir.

Bu işe yarıyor çünkü her JavaScript türünün prototipinde bir "yapıcı" özelliği var .

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


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

Bu basit bir kontrol olmalıdır.

örnek 1

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

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