Comment vérifier si une propriété d'objet existe avec une variable contenant le nom de la propriété?

Je vérifie l'existence d'une propriété d'objet avec une variable contenant le nom de la propriété en question.

var myObj;
myObj.prop = "exists";
var myProp = "p"+"r"+"o"+"p";

if(myObj.myProp){
    alert("yes, i have that property");
};

C'est undefinedparce qu'il cherche myObj.myPropmais je veux qu'il vérifiemyObj.prop

var myProp = 'prop';
if(myObj.hasOwnProperty(myProp)){
    alert("yes, i have that property");
}

Ou

var myProp = 'prop';
if(myProp in myObj){
    alert("yes, i have that property");
}

Ou

if('prop' in myObj){
    alert("yes, i have that property");
}

Notez que hasOwnPropertyne vérifie pas les propriétés héritées, alors que le infait. Par exemple, 'constructor' in myObjc'est vrai, mais ce myObj.hasOwnProperty('constructor')n'est pas le cas.

Vous pouvez utiliser hasOwnProperty , mais en fonction de la référence, vous avez besoin de guillemets lorsque vous utilisez cette méthode:

if (myObj.hasOwnProperty('myProp')) {
    // do something
}

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

Une autre façon est d'utiliser dans l' opérateur, mais vous avez besoin de devis ici aussi:

if ('myProp' in myObj) {
    // do something
}

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

Merci pour l'assistance de tout le monde et pour avoir poussé à se débarrasser de la déclaration eval. Les variables devaient être entre parenthèses, pas la notation par points. Cela fonctionne et est un code propre et correct.

Chacune de ces variables est: appChoice, underI, underObstr.

if(typeof tData.tonicdata[appChoice][underI][underObstr] !== "undefined"){
    //enter code here
}

Pour sa propre propriété:

var loan = { amount: 150 };
if(Object.prototype.hasOwnProperty.call(loan, "amount")) 
{ 
   //will execute
}

Remarque: il est préférable d' utiliser Object.prototype.hasOwnProperty que loan.hasOwnProperty (..), dans le cas où un hasOwnProperty personnalisé est défini dans la chaîne de prototypes (ce qui n'est pas le cas ici), comme

var foo = {
      hasOwnProperty: function() {
        return false;
      },
      bar: 'Here be dragons'
    };

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

Pour inclure des propriétés héritées dans la recherche, utilisez l' opérateur in : (mais vous devez placer un objet sur le côté droit de 'in', les valeurs primitives génèreront une erreur, par exemple 'length' dans 'home' générera une erreur, mais 'length' dans la nouvelle chaîne ('home') ne le sera pas)

const yoshi = { skulk: true };
const hattori = { sneak: true };
const kuma = { creep: true };
if ("skulk" in yoshi) 
    console.log("Yoshi can skulk");

if (!("sneak" in yoshi)) 
    console.log("Yoshi cannot sneak");

if (!("creep" in yoshi)) 
    console.log("Yoshi cannot creep");

Object.setPrototypeOf(yoshi, hattori);

if ("sneak" in yoshi)
    console.log("Yoshi can now sneak");
if (!("creep" in hattori))
    console.log("Hattori cannot creep");

Object.setPrototypeOf(hattori, kuma);

if ("creep" in hattori)
    console.log("Hattori can now creep");
if ("creep" in yoshi)
    console.log("Yoshi can also creep");

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

Remarque: On peut être tenté d'utiliser l'accesseur typeof et [] comme code suivant qui ne fonctionne pas toujours ...

var loan = { amount: 150 };

loan.installment = undefined;

if("installment" in loan) // correct
{
    // will execute
}

if(typeof loan["installment"] !== "undefined") // incorrect
{
    // will not execute
}

Un moyen beaucoup plus sûr de vérifier si une propriété existe sur l'objet est d'utiliser un objet vide ou un prototype d'objet pour appeler hasOwnProperty()

var foo = {
  hasOwnProperty: function() {
    return false;
  },
  bar: 'Here be dragons'
};

foo.hasOwnProperty('bar'); // always returns false

// Use another Object's hasOwnProperty and call it with 'this' set to foo
({}).hasOwnProperty.call(foo, 'bar'); // true

// It's also possible to use the hasOwnProperty property from the Object
// prototype for this purpose
Object.prototype.hasOwnProperty.call(foo, 'bar'); // true

Référence à partir des documents Web MDN - Object.prototype.hasOwnProperty ()

Vous pouvez utiliser hasOwnProperty()ainsi que l' inopérateur.