Impossibile accedere alla proprietà dell'oggetto, anche se viene visualizzato in un registro della console

Di seguito, puoi vedere l'output di questi due registri. Il primo mostra chiaramente l'oggetto completo con la proprietà a cui sto tentando di accedere, ma sulla riga di codice immediatamente successiva non riesco ad accedervi config.col_id_3(vedi "non definito" nello screenshot?). Qualcuno può spiegare questo? Posso ottenere l'accesso a tutte le altre proprietà tranne field_id_4anche.

console.log(config);
console.log(config.col_id_3);

Questo è ciò che queste linee stampano in Console

L'output di console.log(anObject)è fuorviante; lo stato dell'oggetto visualizzato viene risolto solo quando si espande >nella console. E ' non è lo stato dell'oggetto quando si console.log'd l'oggetto.

Invece, prova console.log(Object.keys(config))o anche console.log(JSON.stringify(config))e vedrai le chiavi o lo stato dell'oggetto nel momento in cui hai chiamato console.log.

Troverai (di solito) che i tasti vengono aggiunti dopo la console.logchiamata.

Ho appena avuto questo problema con un documento caricato da MongoDB usando Mongoose .

Quando viene eseguito console.log()sull'intero oggetto, vengono visualizzati tutti i campi del documento (come memorizzati nel database). Tuttavia, alcuni accessori di proprietà individuali ritornerebbero undefined, quando altri (incluso _id) funzionavano bene.

Si è scoperto che gli accessori di proprietà funzionano solo per quei campi specificati nella mia mongoose.Schema(...)definizione, mentre console.log()e JSON.stringify()restituisce tutti i campi memorizzati nel database.

Soluzione (se si utilizza Mongoose) : assicurarsi che tutti i campi db siano definiti in mongoose.Schema(...).

Controlla se all'interno dell'oggetto c'è una matrice di oggetti. Ho avuto un problema simile con un JSON:

    "terms": {
        "category": [
            {
                "ID": 4,
                "name": "Cirugia",
                "slug": "cirugia",
                "description": "",
                "taxonomy": "category",
                "parent": null,
                "count": 68,
                "link": "http://distritocuatro.mx/enarm/category/cirugia/"
            }
        ]
    }

Ho provato ad accedere alla chiave "name" da "categoria" e ho riscontrato l' errore indefinito , perché stavo usando:

var_name = obj_array.terms.category.name

Poi ho capito che ha parentesi quadre, il che significa che ha una matrice di oggetti all'interno della chiave di categoria, perché può avere più di un oggetto di categoria. Quindi, per ottenere la chiave "name" ho usato questo:

var_name = obj_array.terms.category[0].name

E questo fa il trucco.

Forse è troppo tardi per questa risposta, ma spero che qualcuno con lo stesso problema lo troverà come ho fatto prima di trovare la soluzione :)

Ho avuto lo stesso problema. La soluzione per me era usare l'output con stringhe come input per analizzare JSON. questo ha funzionato per me. spero che ti sia utile

var x =JSON.parse(JSON.stringify(obj));
console.log(x.property_actually_now_defined);

La proprietà a cui stai tentando di accedere potrebbe non esistere ancora. Console.log funziona perché viene eseguito dopo un piccolo ritardo, ma non è il caso del resto del codice. Prova questo:

var a = config.col_id_3;    //undefined

setTimeout(function()
{
    var a = config.col_id_3;    //voila!

}, 100);

Nel mio caso stavo passando un oggetto a una promessa, all'interno della promessa stavo aggiungendo più chiave / valori all'oggetto e quando è stato fatto la promessa ha restituito l'oggetto.

Tuttavia, una leggera occhiata da parte mia, la promessa era di restituire l'oggetto prima che fosse completamente finito ... quindi il resto del mio codice stava cercando di elaborare l'oggetto aggiornato e i dati non erano ancora lì. Ma come sopra, nella console, ho visto l'oggetto completamente aggiornato ma non ero in grado di accedere alle chiavi: stavano tornando indefinito. Fino a quando ho visto questo:

console.log(obj) ;
console.log(obj.newKey1) ;

// returned in console
> Object { origKey1: "blah", origKey2: "blah blah"} [i]
    origKey1: "blah"
    origKey2: "blah blah"
    newKey1: "this info"
    newKey2: "that info"
    newKey3: " more info"
> *undefined*

La [i] è una piccola icona, quando ci ho sopra ho detto Object value at left was snapshotted when logged, value below was evaluated just now. Quello è quando mi è venuto in mente che il mio oggetto veniva valutato prima che la promessa lo avesse completamente aggiornato.

Ho lottato con questo problema oggi e ho pensato di lasciare una risposta con la mia soluzione.

Stavo recuperando un oggetto dati tramite Ajax, qualcosa del genere: {"constants": {"value1":"x","value2":"y"},"i18n" {"data1":"x", "data2":"y"}}

Diciamo che questo oggetto si trova in una variabile chiamata data. Ogni volta che ho fatto riferimento data.i18nho ottenuto undefined.

1. console.log(data) ha mostrato l'oggetto come previsto
2. console.log(Object.keys(data))detto ["constants","i18n"]come previsto
3. Rinominare i18n in inter non ha cambiato nulla
4. Ho anche provato a cambiare i dati per rendere "i18n" il primo oggetto
5. Spostato il codice per assicurarsi che l'oggetto fosse completamente impostato e non ci fossero problemi con la promessa Ajax.

Nulla ha aiutato ... Poi sul lato server ho scritto i dati nel registro php, e ha rivelato questo:

{"constants": {"value1":"x","value2":"y"},"\u045618n" {"data1":"x", "data2":"y"}}

La "i" nella chiave di indice era in realtà un u0456 (i cirillico). Questo non era visibile nel mio editor php o nel registro della console del browser. Solo il registro php ha rivelato questo ... È stato difficile ...

I miei dati erano solo una stringa di dati json. (Questa variabile è stata memorizzata come stringa json nella sessione).

console.log(json_string_object)

-> restituisce solo la rappresentazione di questa stringa e non c'è modo di fare differenza se si tratta di stringa o oggetto.

Quindi per farlo funzionare ho solo bisogno di riconvertirlo in oggetto reale:

object = JSON.parse(json_string_object);

Nel 2018 Mozilla ci mette in guardia su Mozilla Docs qui !

Cito "Oggetti di registrazione" :

Non usare console.log(obj);, usa console.log(JSON.parse(JSON.stringify(obj)));.

In questo modo sei sicuro di vedere il valore di obj al momento della registrazione.

Questo potrebbe aiutare qualcuno in quanto ho avuto un problema simile in cui JSON.parse () restituiva un oggetto che potevo stampare su console.log () ma non potevo accedere ai campi specifici e nessuna delle soluzioni precedenti ha funzionato per me. Come usare la combinazione di JSON.parse () con JSON.stringify ().

var jsonObj = JSON.parse(JSON.stringify(responseText))

// where responseText is a JSON String returned by the server.

console.log(jsonObj) ///Was printing the object correctly
console.log(jsonObj.Body) /// Was printing Undefined  

Ho finito per risolvere il problema utilizzando un diverso parser fornito da ExtJs Ext.decode ();

var jsonObj = Ext.decode(responseText)
console.log(jsonObj.Body) //Worked...

Nel mio caso, capita semplicemente che anche se ricevo i dati nel formato di un modello come myMethod(data:MyModelClass) oggetto fino a quando l'oggetto ricevuto non fosse di tipo stringa. Che è y in console.log (dati) ottengo il contenuto. La soluzione è solo per analizzare il JSON (nel mio caso)

const model:MyMOdelClass=JSON.parse(data);

Il pensiero può essere utile.

Ho appena riscontrato questo problema con oggetti generati da CSV-parser da un file CSV generato da MS Excel. Sono stato in grado di accedere a tutte le proprietà tranne la prima proprietà - ma sarebbe apparso ok se avessi scritto l'intero oggetto usando console.log.

Si è scoperto che il formato CSV UTF-8 inserisce 3 byte (ef bb bf) all'inizio corrispondenti a un carattere invisibile - che sono stati inclusi come parte della prima intestazione della proprietà da csv-parser. La soluzione era quella di rigenerare il CSV usando l'opzione non UTF e questo ha eliminato il carattere invisibile.

Ho avuto un problema simile, spero che la seguente soluzione aiuti qualcuno.
Puoi usare la setTimeoutfunzione come suggeriscono alcuni ragazzi qui, ma non sai mai quanto tempo richiede il tuo browser per definire il tuo oggetto.

Per questo suggerirei setIntervalinvece di usare la funzione. Attenderà fino a quando l'oggetto non config.col_id_3verrà definito e quindi eseguirà la parte di codice successiva che richiede le proprietà dell'oggetto specifico.

window.addEventListener('load', function(){

    var fileInterval = setInterval(function() {
        if (typeof config.col_id_3 !== 'undefined') {

            // do your stuff here

            clearInterval(fileInterval); // clear interval
        }
    }, 100); // check every 100ms

});

se stai usando TYPESCRIPTe / o ANGULAR, potrebbe essere questo!

.then((res: any) => res.json())

impostando il tipo di risposta su qualsiasi risolto questo problema per me, non ho potuto accedere alle proprietà della risposta finché non ho impostato res: any

vedi questa domanda La proprietà '_body' non esiste sul tipo 'Response'

Ho avuto lo stesso problema e nessuna soluzione sopra ha funzionato per me e mi è sembrato di pensare a un lavoro successivo. Tuttavia, racchiudere il mio codice che crea l'oggetto in una setTimeoutfunzione ha funzionato per me.

setTimeout(function() {
   var myObj = xyz; //some code for creation of complex object like above
   console.log(myObj); // this works
   console.log(myObj.propertyName); // this works too
});

Ho avuto un problema simile o forse solo correlato.

Nel mio caso stavo accedendo alle proprietà di un oggetto ma uno non era definito. Ho scoperto che il problema era uno spazio vuoto nel codice lato server durante la creazione della chiave, val dell'oggetto.

Il mio approccio era il seguente ...

Dopo aver rimosso gli spazi bianchi dal codice sul lato server creando l'oggetto, ora potevo accedere alla proprietà come di seguito ...

Questo potrebbe non essere il problema con il caso della questione in oggetto, ma era per il mio caso e potrebbe essere così per qualcun altro. Spero che sia d'aiuto.

Ho appena avuto lo stesso problema con un documento caricato da MongoDB usando Mongoose.

Venne fuori che sto usando la proprietà find()per restituire solo un oggetto, così ho cambiato find()per findOne()e tutto ha funzionato per me.

Soluzione (se si utilizza Mongoose): assicurarsi di restituire un solo oggetto, in modo da poterne analizzare object.ido verrà trattato come un array, quindi è necessario accedervi in ​​questo modo object[0].id.

Per me si è rivelato essere un problema legato alla mangusta.

Stavo eseguendo il loop su oggetti ottenuti da una query Mongo. Ho dovuto solo rimuovere:

items = await Model.find()

E sostituiscilo con:

items = await Model.find().lean()

Ho avuto un problema come questo e ho scoperto che la soluzione era quella di Underscore.js. La mia registrazione iniziale non aveva senso:

console.log(JSON.stringify(obj, null, 2));

> {
>   "code": "foo"
> }

console.log(obj.code);

> undefined

Ho trovato la soluzione guardando anche le chiavi dell'oggetto:

console.log(JSON.stringify(Object.keys(obj)));

> ["_wrapped","_chain"]

Questo mi ha portato a capire che in objrealtà era un wrapper Underscore.js attorno a un oggetto e il debug iniziale mi stava mentendo.

Ho avuto un problema simile (durante lo sviluppo per SugarCRM), dove inizio con:

var leadBean = app.data.createBean('Leads', {id: this.model.attributes.parent_id});

// This should load object with attributes 
leadBean.fetch();

// Here were my attributes filled in with proper values including name
console.log(leadBean);

// Printed "undefined"
console.log(leadBean.attributes.name);

Il problema era presente fetch(), la sua chiamata asincrona quindi ho dovuto riscrivere il mio codice in:

var leadBean = app.data.createBean('Leads', {id: this.model.attributes.parent_id});

// This should load object with attributes 
leadBean.fetch({
    success: function (lead) {
        // Printed my value correctly
        console.log(lead.attributes.name);
    }
});

Nel caso in cui questo sia utile per qualcuno, ho avuto un problema simile, ed è perché qualcuno ha creato un override per .toJSON nell'oggetto con cui stavo lavorando. Quindi l'oggetto era qualcosa di simile:

{
  foo: {
         bar: "Hello"
         baz: "World"
       }
}

Ma .toJSON () era:

toJSON() {
  return this.foo
}

Quindi quando ho chiamato JSON.stringify (myObject) ha restituito "{" bar ":" Hello "," baz ":" World "}". Tuttavia, Object.keys (myObject) ha rivelato il "pippo".

Ho affrontato lo stesso problema oggi. Nel mio caso le chiavi erano nidificate, ovvero key1.key2. Ho diviso le chiavi usando split () e poi ho usato la notazione parentesi quadra, che ha funzionato per me.

var data = {
    key1: {
          key2: "some value"
       }
}

Ho diviso le chiavi e l'ho usato in questo modo, data [chiave1] [chiave2] che ha fatto il lavoro per me.

Ho avuto lo stesso problema oggi. Il problema è stato causato da uglify-js. Dopo aver eseguito lo stesso codice non uguito, il problema è stato risolto. Rimozione di

--mangle-props

da uglify-js è bastato avere un codice funzionante.

Forse, la migliore pratica è usare un prefisso per le proprietà che devono essere modificate con la regola regex per uglify-js.

Ecco la fonte:

var data = JSON.parse( content);
...
this.pageIndex = parseInt(data.index);
this.pageTotal = parseInt(data.total);
this.pageLimit = parseInt(data.limit); 

ed ecco come è stato semplificato:

var n = JSON.parse( t);
...
this._ = parseInt(n.index), this.g = parseInt(n.total), this.D = parseInt(n.C)

Nessuno dei stringify / parse JSON ha funzionato per me.

formValues.myKey:               undefined
formValues.myKey with timeout:  content

Volevo il valore di formValues.myKeye che cosa ha fatto il trucco era un setTimeout 0 come nell'esempio qui sotto. Spero che sia d'aiuto.

console.log('formValues.myKey: ',formValues.myKey);
setTimeout( () => { 
  console.log('formValues.myKey with timeout: ', formValues.myKey);
}, 0 );

Ho riscontrato anche questo problema, e per farla breve la mia API stava restituendo un tipo di stringa e non JSON. Quindi sembrava esattamente lo stesso quando lo hai stampato nel registro, tuttavia ogni volta che ho provato ad accedere alle proprietà mi ha dato un errore indefinito.

Codice API:

     var response = JsonConvert.DeserializeObject<StatusResult>(string Of object);
     return Json(response);

in precedenza stavo solo tornando:

return Json(string Of object);

Ho avuto un problema simile oggi in React. Alla fine si rese conto che il problema era stato causato dallo stato non ancora impostato. Stavo chiamando user.user.namee sebbene fosse visualizzato nella console, non riuscivo ad accedere al mio componente fino a quando non ho incluso un controllo per verificare se user.userera impostato e quindi chiamare user.user.name.