Wat betekent [object Object]?

Ik probeer een geretourneerde waarde van een functie te waarschuwen en ik krijg dit in de waarschuwing:

[object Object]  

Hier is de JavaScript-code:

<script type="text/javascript">
$(function ()
{
    var $main = $('#main'),
    $1 = $('#1'),
    $2 = $('#2');
    $2.hide(); // hide div#2 when the page is loaded
    $main.click(function ()
    {
        $1.toggle();
        $2.toggle();
    });
    $('#senddvd').click(function ()
    {
       alert('hello');
       var a=whichIsVisible();
       alert(whichIsVisible());
    });
    function whichIsVisible()
    {
        if (!$1.is(':hidden')) return $1;
        if (!$2.is(':hidden')) return $2;
    }
});
</script>

whichIsVisibleis de functie die ik probeer te controleren.

Antwoord 1, autoriteit 100%

De standaardconversie van een object naar een tekenreeks is "[object Object]".

Omdat je met jQuery-objecten te maken hebt, zou je dit misschien willen doen

alert(whichIsVisible()[0].id);

om de ID van het element af te drukken.

Zoals vermeld in de opmerkingen, moet u de tools in browsers zoals Firefox of Chrome gebruiken om objecten te introspecteren door console.log(whichIsVisible())te doen in plaats van alert.

Sidenote: ID’s mogen niet beginnen met cijfers.

Antwoord 2, autoriteit 94%

Zoals anderen al hebben opgemerkt, is dit de standaard serialisatie van een object. Maar waarom is het [object Object]en niet alleen [object]?

Dat komt omdat er verschillende soorten objecten in Javascript zijn!

• Functie-objecten:
  stringify(function (){})-> [object Function]
• Array-objecten:
  stringify([])-> [object Array]
• RegExp-objecten
  stringify(/x/)-> [object RegExp]
• Datumobjecten
  stringify(new Date)-> [object Date]
• meer
• en Objectobjecten!
  stringify({})-> [object Object]

Dat komt omdat de constructorfunctie Objectwordt genoemd (met een hoofdletter “O”), en de term “object” (met kleine “o”) verwijst naar de structurele aard van het ding.

Als je het in Javascript over “objecten” hebt, bedoel je in feite “Objectobjecten“, en niet de andere typen.

_{waar stringifyer als volgt uit moet zien:}

function stringify (x) {
    console.log(Object.prototype.toString.call(x));
}

Antwoord 3, autoriteit 41%

[object Object]is de standaard toString-representatie van een object in javascript.

Als je de eigenschappen van je object wilt weten, ga er dan als volgt overheen:

for(var property in obj) {
    alert(property + "=" + obj[property]);
}

In jouw specifieke geval krijg je een jQuery-object. Probeer in plaats daarvan dit:

$('#senddvd').click(function ()
{
   alert('hello');
   var a=whichIsVisible();
   alert(whichIsVisible().attr("id"));
});

Dit zou de id van het zichtbare element moeten waarschuwen.

Antwoord 4, autoriteit 29%

Je kunt de waarde binnen [object Object] op deze manier zien

Alert.alert(  JSON.stringify(userDate)  );

Probeer het zo

   realm.write(() => {
       const userFormData = realm.create('User',{
       user_email: value.username,
       user_password: value.password,
      });
     });
      const userDate = realm.objects('User').filtered('user_email == $0', value.username.toString(), );
      Alert.alert(  JSON.stringify(userDate)  );

referentie

https://off.tokyo/blog/react-native-object-object /

Antwoord 5, autoriteit 21%

Basis

Je weet het misschien niet, maar wanneer we in JavaScript interageren met tekenreeksen, getallen of booleaanse primitieven, komen we in een verborgen wereld van objectschaduwen en dwang.

tekenreeks, getal, boolean, null, undefined en symbool.

In JavaScript zijn er 7 primitieve typen: undefined, null, Boolean, String, Number, biginten symbol. Al het andere is een object. De primitieve typen Boolean, Stringen Numberkunnen worden ingepakt door hun objecttegenhangers. Deze objecten zijn instanties van respectievelijk de constructors Boolean, Stringen Number.

typeof true; //"boolean"
typeof new Boolean(true); //"object"
typeof "this is a string"; //"string"
typeof new String("this is a string"); //"object"
typeof 123; //"number"
typeof new Number(123); //"object"

Als primitieven geen eigenschappen hebben, waarom retourneert "this is a string".lengthdan een waarde?

Omdat JavaScript gemakkelijk tussen primitieven en objecten kan dwingen. In dit geval wordt de tekenreekswaarde gedwongen naar een tekenreeksobject om toegang te krijgen tot de eigenschapslengte. Het string-object wordt slechts een fractie van een seconde gebruikt, waarna het wordt geofferd aan de goden van de vuilnisophaaldienst maar in de geest van de tv-ontdekkingsshows zullen we het ongrijpbare wezen vangen en bewaren voor verdere analyse

Om dit aan te tonen, moet u het volgende voorbeeld bekijken waarin we een nieuwe eigenschap toevoegen aan het String-constructor-prototype.

String.prototype.sampleProperty = 5;
var str = "this is a string";
str.sampleProperty;            // 5

Op deze manier hebben primitieven toegang tot alle eigenschappen (inclusief methoden) die zijn gedefinieerd door hun respectievelijke objectconstructeurs.

Dus we zagen dat primitieve typen op gepaste wijze hun respectieve Object-tegenhanger zullen dwingen wanneer dat nodig is.

Analyse van de methode toString()

Denk aan de volgende code

var myObj    = {lhs: 3, rhs: 2};
var myFunc   = function(){}
var myString = "This is a sample String";
var myNumber = 4;
var myArray  = [2, 3, 5];
myObj.toString();     // "[object Object]"
myFunc.toString();    // "function(){}"
myString.toString();  // "This is a sample String"
myNumber.toString();  // "4"
myArray.toString();   // "2,3,5"

Zoals hierboven besproken, wat er werkelijk gebeurt, is dat wanneer we de methode toString()op een primitief type aanroepen, deze in zijn objecttegenhanger moet worden gedwongen voordat hij de methode kan aanroepen.
d.w.z. myNumber.toString()is gelijk aan Number.prototype.toString.call(myNumber)en op dezelfde manier voor andere primitieve typen.

Maar wat als in plaats van dat het primitieve type wordt doorgegeven aan de methode toString()van de corresponderende tegenhanger van de objectconstructorfunctie, we het primitieve type dwingen om als parameter door te geven aan toString()methode van Object functie constructor (Object.prototype.toString.call(x))?

Object.prototype.toString() nader bekeken

Volgens de documentatie,
Wanneer de methode toString wordt aangeroepen, worden de volgende stappen genomen:

1. Als de waarde thisundefinedis, retourneert u "[object Undefined]".
2. Als de waarde thisnullis, retourneert u "[object Null]".
3. Als deze waarde geen van bovenstaande is, laat Ohet resultaat zijn van het aanroepen van toObjectwaarbij de waarde thisals argument wordt doorgegeven.
4. Laat class de waarde zijn van de [[Class]]interne eigenschap van O.
5. Retourneer de tekenreekswaarde die het resultaat is van het aaneenschakelen van de drie tekenreeksen "[object ", classen "]".

Begrijp dit uit het volgende voorbeeld

var myObj       = {lhs: 3, rhs: 2};
var myFunc      = function(){}
var myString    = "This is a sample String";
var myNumber    = 4;
var myArray     = [2, 3, 5];
var myUndefined = undefined;
var myNull      = null;
Object.prototype.toString.call(myObj);        // "[object Object]"
Object.prototype.toString.call(myFunc);       // "[object Function]"
Object.prototype.toString.call(myString);     // "[object String]"
Object.prototype.toString.call(myNumber);     // "[object Number]"
Object.prototype.toString.call(myArray);      // "[object Array]"
Object.prototype.toString.call(myUndefined);  // "[object Undefined]"
Object.prototype.toString.call(myNull);       // "[object Null]"

Referenties:
https://es5.github.io/x15.2.html#x15 .2.4.2
https://es5.github.io/x9.html#x9.9
https://javascriptweblog.wordpress.com/ 27/09/2010/het-geheim-leven-van-javascript-primitives/

Antwoord 6, autoriteit 17%

Het is de waarde die wordt geretourneerd door de toString()functie.

Ik begrijp wat je probeert te doen, omdat ik heb beantwoord je vraag gisterenover het bepalen welke div zichtbaar is. 🙂
De functie whichIsVisible()retourneert een echt jQuery-object, omdat ik dacht dat dat programmatischnuttiger zou zijn. Als u deze functie voor foutopsporingsdoeleinden wilt gebruiken, kunt u zoiets als dit doen:

function whichIsVisible_v2()
{
    if (!$1.is(':hidden')) return '#1';
    if (!$2.is(':hidden')) return '#2';
}

Dat gezegd hebbende, zou je eigenlijk een goede debugger moeten gebruikenin plaats van alert()als je een probleem probeert op te lossen. Als je Firefox gebruikt, is Firebuguitstekend. Als je IE8, Safari of Chrome gebruikt, hebben ze ingebouwde debuggers.

Antwoord 7, autoriteit 6%

[object Object]is de standaard tekenreeksrepresentatie van een JavaScript Object. Dit krijg je als je deze code uitvoert:

alert({}); // [object Object]

U kunt de standaardweergave wijzigen door de methode toStringals volgt te overschrijven:

var o = {toString: function(){ return "foo" }};
alert(o); // foo

Antwoord 8, autoriteit 3%

U heeft een javascript-object

$1en $2zijn jQuery-objecten, gebruik misschien alert($1.text());om tekst of alert($1.attr('id');enz…

je moet $1en $2behandelen als jQuery-objecten.

Antwoord 9, autoriteit 2%

U probeert een object te retourneren. Omdat er geen goede manier is om een ​​object als een tekenreeks weer te geven, wordt de waarde van .toString()van het object automatisch ingesteld als "[object Object]".

Antwoord 10, autoriteit 2%

Ik denk dat de beste uitweg is door JSON.stringify()te gebruiken en je gegevens door te geven als param:

alert(JSON.stringify(whichIsVisible()));

Antwoord 11, autoriteit 2%

Beschouw het volgende voorbeeld:

const foo = {};
foo[Symbol.toStringTag] = "bar";
console.log("" + foo);

Welke uitgangen

[object bar]

In principe kan elk object in javascript een eigenschap definiëren met de tag Symbol.toStringTagen de uitvoer overschrijven.

Achter de schermen constructie van een nieuw object in javascript-prototypes van een object met een “toString”-methode. Het standaardobject biedt deze methode als een eigenschap en die methode roept intern de tag op om te bepalen hoe het object tot een tekenreeks moet worden gedwongen. Als de tag aanwezig is, wordt deze gebruikt. Als deze ontbreekt, krijgt u "Object".

Moet je Symbol.toStringTaginstellen? Kan zijn. Maar vertrouwen op de string die altijd [object Object]is voor “echte” objecten is niet het beste idee.

Antwoord 12

Het object waarvan de klasse Object is, lijkt heel anders dan het gebruikelijke instantieobject van de klasse, omdat het werkt als een associatieve array of lijst: het kan worden gemaakt door eenvoudige objectliteralen (een lijst met sleutels en eigenschappen), zoals deze: let obj={A:'a',B:'b'};en omdat het erg op dezelfde letterlijke notatie lijkt wanneer het wordt weergegeven in het deelvenster Developer Tools Console en wanneer het wordt geconverteerd naar een JSON-tekenreeks .

Maar in feite is het enige echte verschil in objecten van andere klassen (die zijn afgeleid of uitgebreid van Object) dat andere klassen meestal constructors en methoden hebben (dit zijn allemaal functies), naast eigenschappen (die variabelen zijn) ). Een klasse-instantieobject wordt toegewezen met behulp van de ‘new’-operator en zijn eigenschappen en methoden zijn toegankelijk via de variabele ‘this’. U kunt ook toegang krijgen tot de onderliggende statische functies die naar elke nieuwe instantie worden gekopieerd door de eigenschap ‘prototype’ te gebruiken, en zelfs systeemklassen uitbreiden door nieuwe functies aan hun prototypeobject toe te voegen.

Het Array-object is ook afgeleid van Object en wordt vaak gebruikt: het is een geordende, 0-geïndexeerde array van variabele waarden.

Objectobjecten worden, in tegenstelling tot arrays en andere klassen, eenvoudigweg behandeld als associatieve arrays (soms als geordend en soms als ongeordend beschouwd).