Was bedeutet [Objekt Objekt]?

Ich versuche, einen zurückgegebenen Wert von einer Funktion zu alarmieren, und erhalte dies in der Warnung:

[object Object]  

Hier ist der 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>

whichIsVisible ist die Funktion, die ich überprüfen möchte.

Die Standardkonvertierung von einem Objekt in eine Zeichenfolge ist "[object Object]".

Wenn Sie mit jQuery-Objekten arbeiten, möchten Sie dies möglicherweise tun

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

um die ID des Elements zu drucken.

Wie in den Kommentaren erwähnt, sollten Sie die in Browsern wie Firefox oder Chrome enthaltenen Tools verwenden, um Objekte zu überprüfen, indem Sie console.log(whichIsVisible())stattdessen ausführen alert.

Nebenbemerkung : IDs sollten nicht mit Ziffern beginnen.

Wie andere angemerkt haben, ist dies die Standardserialisierung eines Objekts. Aber warum ist es so [object Object]und nicht nur [object]?

Das liegt daran, dass es in Javascript verschiedene Arten von Objekten gibt!

• Funktionsobjekte :
  stringify(function (){})->[object Function]
• Array-Objekte :
  stringify([])->[object Array]
• RegExp-Objekte
  stringify(/x/) ->[object RegExp]
• Datumsobjekte
  stringify(new Date) ->[object Date]
• … Noch einige …
• und Objektobjekte !
  stringify({})->[object Object]

Das liegt daran, dass die Konstruktorfunktion aufgerufen wird Object(mit einem Großbuchstaben "O") und der Begriff "Objekt" (mit einem kleinen "o") sich auf die strukturelle Natur des Dings bezieht.

Wenn Sie in Javascript von "Objekten" sprechen, meinen Sie normalerweise " Objektobjekte " und nicht die anderen Typen.

_{wo stringifysollte das so aussehen:}

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

[object Object] ist die Standard-toString-Darstellung eines Objekts in Javascript.

Wenn Sie die Eigenschaften Ihres Objekts kennenlernen möchten, gehen Sie einfach wie folgt vor:

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

In Ihrem speziellen Fall erhalten Sie ein jQuery-Objekt. Versuchen Sie stattdessen Folgendes:

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

Dies sollte die ID des sichtbaren Elements warnen.

Dies ist der Wert, der von der toString()Funktion dieses Objekts zurückgegeben wird.

Ich verstehe, was Sie versuchen, weil ich gestern Ihre Frage beantwortet habe , welche Div sichtbar ist. :)
Die whichIsVisible()Funktion gibt ein tatsächliches jQuery-Objekt zurück, da ich dachte, das wäre programmatisch nützlicher. Wenn Sie diese Funktion zum Debuggen verwenden möchten, können Sie Folgendes tun:

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

Das heißt, Sie sollten wirklich einen richtigen Debugger verwenden, anstatt zu alert()versuchen, ein Problem zu debuggen. Wenn Sie Firefox verwenden, ist Firebug ausgezeichnet. Wenn Sie IE8, Safari oder Chrome verwenden, verfügen sie über integrierte Debugger.

Sie können den Wert in [Objekt Objekt] so sehen

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

Versuchen Sie es so

    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)  );

Referenz

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

Grundlagen

Sie wissen es vielleicht nicht, aber wenn wir in JavaScript mit Zeichenfolgen, Zahlen oder booleschen Grundelementen interagieren, betreten wir eine verborgene Welt von Objektschatten und Zwang.

Zeichenfolge, Zahl, Boolescher Wert, Null, undefiniert und Symbol.

In JavaScript gibt es 7 Urtyp: undefined, null, boolean, string, number, bigintund symbol. Alles andere ist ein Objekt. Die primitiven Typen boolean, stringund numberkönnen durch ihr Objekt Pendants gewickelt werden. Diese Objekte sind Instanzen von der Boolean, Stringund NumberKonstrukteure sind.

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"

Wenn Grundelemente keine Eigenschaften haben, warum wird "this is a string".lengthein Wert zurückgegeben?

Weil JavaScript leicht zwischen Grundelementen und Objekten zwingt. In diesem Fall wird der Zeichenfolgenwert zu einem Zeichenfolgenobjekt gezwungen, um auf die Eigenschaftslänge zuzugreifen. Das String-Objekt wird nur für den Bruchteil einer Sekunde verwendet, danach wird es den Göttern der Müllabfuhr geopfert - aber im Geiste der TV-Entdeckungsshows werden wir die schwer fassbare Kreatur fangen und für weitere Analysen aufbewahren ...

Um dies weiter zu demonstrieren, betrachten Sie das folgende Beispiel, in dem wir dem String-Konstruktor-Prototyp eine neue Eigenschaft hinzufügen.

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

Auf diese Weise haben Grundelemente Zugriff auf alle Eigenschaften (einschließlich Methoden), die von ihren jeweiligen Objektkonstruktoren definiert wurden.

Wir haben also gesehen, dass primitive Typen bei Bedarf angemessen zu ihrem jeweiligen Objekt-Gegenstück gezwungen werden.

Analyse der toString()Methode

Betrachten Sie den folgenden 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"

Wie oben erläutert, geschieht das, was wir tun, wenn wir eine toString()Methode für einen primitiven Typ aufrufen , sie in ihr Objektgegenstück gezwungen, bevor sie die Methode aufrufen kann.
dh myNumber.toString()ist äquivalent Number.prototype.toString.call(myNumber)und ähnlich für andere primitive Typen.

Was aber, wenn anstelle der Übergabe des primitiven Typs an die toString()Methode des entsprechenden Gegenstücks zur Objektkonstruktorfunktion der primitive Typ als Parameter an die toString()Methode des Objektfunktionskonstruktors ( Object.prototype.toString.call(x)) übergeben wird?

Schauen Sie sich Object.prototype.toString () genauer an

Gemäß der Dokumentation werden beim Aufrufen der toString-Methode die folgenden Schritte ausgeführt:

1. Wenn der thisWert ist undefined, geben Sie zurück "[object Undefined]".
2. Wenn der thisWert ist null, geben Sie zurück "[object Null]".
3. Wenn dieser Wert keiner der oben genannten Werte ist, sei Odas Ergebnis des Aufrufs toObject, den thisWert als Argument zu übergeben.
4. Klasse sei der Wert der [[Class]]internen Eigenschaft von O.
5. Gibt den String - Wert, der das Ergebnis der Verkettung der drei Strings ist "[object ", classund "]".

Verstehen Sie dies anhand des folgenden Beispiels

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]"

Referenzen: https://es5.github.io/x15.2.html#x15.2.4.2 https://es5.github.io/x9.html#x9.9 https://javascriptweblog.wordpress.com/ 2010/09/27 / das geheime Leben von Javascript-Primitiven /

[object Object]ist die Standard-Zeichenfolgendarstellung eines JavaScript Object. Es ist das, was Sie erhalten, wenn Sie diesen Code ausführen:

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

Sie können die Standarddarstellung ändern, indem Sie die toStringMethode wie folgt überschreiben :

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

Sie haben ein Javascript-Objekt

$1und $2sind jquery Objekte, vielleicht verwenden alert($1.text());, um Text oder alert($1.attr('id');etc ...

du musst behandeln $1und$2 jQuery-Objekte mögen.

Sie versuchen, ein Objekt zurückzugeben. Da es keine gute Möglichkeit gibt, ein Objekt als Zeichenfolge darzustellen, wird der .toString()Wert des Objekts automatisch als festgelegt "[object Object]".