¿Cómo verificar si la propiedad del objeto existe con una variable que contiene el nombre de la propiedad?

Estoy verificando la existencia de una propiedad de objeto con una variable que contenga el nombre de la propiedad en cuestión.

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

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

Esto se undefineddebe a que está buscando myObj.myProppero quiero que verifiquemyObj.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");
}

Tenga en cuenta que hasOwnPropertyno verifica las propiedades heredadas, mientras que insí. Por ejemplo 'constructor' in myObjes cierto, pero myObj.hasOwnProperty('constructor')no lo es.

Puede usar hasOwnProperty , pero según la referencia, necesita comillas cuando usa este método:

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

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

Otra forma es usarlo en el operador, pero también necesita citas aquí:

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

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

Gracias por la ayuda de todos y presionando para deshacerse de la declaración eval. Las variables deben estar entre paréntesis, no con notación de puntos. Esto funciona y es un código limpio y adecuado.

Cada una de estas son variables: appChoice, underI, underObstr.

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

Para propiedad propia:

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

Nota: usar Object.prototype.hasOwnProperty es mejor que loan.hasOwnProperty (..), en caso de que un hasOwnProperty personalizado se defina en la cadena de prototipos (que no es el caso aquí), como

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

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

Para incluir propiedades heredadas en el hallazgo, use el operador in : (pero debe colocar un objeto en el lado derecho de 'in', los valores primitivos arrojarán un error, por ejemplo, 'length' en 'home' arrojará un error, pero 'length' en la nueva cadena ('casa') no)

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: Uno puede verse tentado a usar typeof y [] el descriptor de acceso de propiedad como el siguiente código que no siempre funciona ...

var loan = { amount: 150 };

loan.installment = undefined;

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

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

Una forma mucho más segura de verificar si existe una propiedad en el objeto es usar un objeto vacío o un prototipo de objeto para llamar 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

Referencia de MDN Web Docs - Object.prototype.hasOwnProperty ()

Puede usar hasOwnProperty()tan bien como inoperador.