Come verificare se esiste una proprietà oggetto con una variabile che contiene il nome della proprietà?

Sto verificando l'esistenza di una proprietà dell'oggetto con una variabile che contiene il nome della proprietà in questione.

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

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

Questo undefinedperché è alla ricerca, myObj.myPropma voglio che controllimyObj.prop

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

O

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

O

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

Nota che hasOwnPropertynon controlla le proprietà ereditate, invece in. Ad esempio 'constructor' in myObjè vero, ma myObj.hasOwnProperty('constructor')non lo è.

È possibile utilizzare hasOwnProperty , ma in base al riferimento sono necessarie le virgolette quando si utilizza questo metodo:

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

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

Un altro modo è quello di utilizzare in operatore, ma è necessario anche virgolette qui:

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

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

Grazie per l'assistenza di tutti e spingendo per sbarazzarsi della dichiarazione di valutazione. Le variabili dovevano essere tra parentesi, non con la notazione a punti. Funziona ed è pulito, codice corretto.

Ognuna di queste sono variabili: appChoice, underI, underObstr.

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

Per la propria proprietà:

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

Nota: l'utilizzo di Object.prototype.hasOwnProperty è meglio di loan.hasOwnProperty (..), nel caso in cui hasOwnProperty personalizzato sia definito nella catena di prototipi (che qui non è il caso), come

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

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

Per includere le proprietà ereditate nel ritrovamento utilizzare il in operator: (ma è necessario posizionare un oggetto sul lato destro di 'in', i valori primitivi getteranno errore, ad esempio 'lunghezza' a 'casa' getteranno errore, ma 'lunghezza' nella nuova stringa ('home') non lo farà)

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

Nota: si può essere tentati di usare typeof e [] accessor delle proprietà come il seguente codice che non funziona sempre ...

var loan = { amount: 150 };

loan.installment = undefined;

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

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

Un modo molto più sicuro per verificare se esiste proprietà sull'oggetto consiste nell'utilizzare un oggetto vuoto o un prototipo di oggetto da chiamare 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

Riferimento da MDN Web Docs - Object.prototype.hasOwnProperty ()

È possibile utilizzare hasOwnProperty()come pure inoperatore.