Cómo verificar si existe un valor en un objeto usando JavaScript

Tengo un objeto en JavaScript:

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

¿Cómo verifico que test1 existe en el objeto como un valor?

Puede convertir los valores de un objeto en una matriz y probar que hay una cadena. Asume que el Objeto no está anidado y la cadena es una coincidencia exacta:

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

Puede utilizar el método Array .some:

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

Tratar:

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

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

O

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

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

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

Esto no funcionará para NaNy -0para esos valores. Puede usar (en lugar de ===) las novedades de ECMAScript 6:

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

Con los navegadores modernos también puede utilizar:

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

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

Usa un for...inbucle:

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

ES6 + un trazador de líneas más corto:

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

Puede utilizar Object.values ​​() :

El Object.values()método devuelve una matriz de valores de propiedad enumerables propios de un objeto dado, en el mismo orden que el proporcionado por un for...inbucle (la diferencia es que un bucle for-in también enumera las propiedades en la cadena del prototipo).

y luego use el método indexOf () :

El indexOf()método devuelve el primer índice en el que se puede encontrar un elemento dado en la matriz, o -1 si no está presente.

Por ejemplo:

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

A continuación, se muestra un ejemplo más detallado:

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

Hice una prueba con todos estos ejemplos y ejecuté esto en Node.js v8.11.2 . Toma esto como una guía para seleccionar tu mejor opció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")

Salida en mi servidor

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

Para una sola línea, diría:

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

Puedes probar esto:

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

puedes probar este

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

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

findSpecificStr(obj, 'test1');

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

Función llamada:

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

El método Object.values ​​() devolvió una matriz (asignada a getValuesOfObject) que contiene los valores de propiedad enumerables propios del objeto dado (obj). La matriz se repitió utilizando el forbucle para recuperar cada valor (valores en getValuesfromObject) y devuelve una función booleana () para averiguar si la expresión ("texto1" es un valor en la matriz de bucle) es verdadera.

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

La respuesta simple a esto se da a continuación.

Esto funciona porque cada tipo de JavaScript tiene una propiedad de “constructor” en su prototipo ”.

Esto debería ser una simple verificación.

Ejemplo 1

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

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