Que signifie [objet objet]?

J'essaye d'alerter une valeur retournée d'une fonction et j'obtiens ceci dans l'alerte:

[object Object]  

Voici le code JavaScript:

<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 est la fonction que j'essaye de vérifier.

La conversion par défaut d'un objet en chaîne est "[object Object]".

Comme vous traitez avec des objets jQuery, vous voudrez peut-être faire

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

pour imprimer l'ID de l'élément.

Comme mentionné dans les commentaires, vous devez utiliser les outils inclus dans les navigateurs comme Firefox ou Chrome pour introspecter les objets en faisant console.log(whichIsVisible())au lieu de alert.

Remarque : les identifiants ne doivent pas commencer par des chiffres.

Comme d'autres l'ont noté, il s'agit de la sérialisation par défaut d'un objet. Mais pourquoi [object Object]et pas seulement [object]?

En effet, il existe différents types d'objets en Javascript!

• Objets de fonction :
  stringify(function (){})->[object Function]
• Objets du tableau :
  stringify([])->[object Array]
• Objets RegExp
  stringify(/x/) ->[object RegExp]
• Objets de date
  stringify(new Date) ->[object Date]
• … Plusieurs autres …
• et objets objets !
  stringify({})->[object Object]

C'est parce que la fonction constructeur est appelée Object(avec un "O" majuscule), et le terme "objet" (avec un petit "o") se réfère à la nature structurelle de l'objet.

Habituellement, lorsque vous parlez d '"objets" en Javascript, vous voulez dire en fait " objets objets ", et non les autres types.

_{où stringifydevrait ressembler à ceci:}

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

[object Object] est la représentation toString par défaut d'un objet en javascript.

Si vous voulez connaître les propriétés de votre objet, il vous suffit de les parcourir comme ceci:

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

Dans votre cas particulier, vous obtenez un objet jQuery. Essayez plutôt de faire ceci:

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

Cela devrait alerter l'id de l'élément visible.

C'est la valeur renvoyée par la toString()fonction de cet objet .

Je comprends ce que vous essayez de faire, car j'ai répondu hier à votre question sur la détermination des div visibles. :)
La whichIsVisible()fonction renvoie un objet jQuery réel, car je pensais que ce serait plus utile par programme . Si vous souhaitez utiliser cette fonction à des fins de débogage, vous pouvez simplement faire quelque chose comme ceci:

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

Cela dit, vous devriez vraiment utiliser un débogueur approprié plutôt que alert()si vous essayez de déboguer un problème. Si vous utilisez Firefox, Firebug est excellent. Si vous utilisez IE8, Safari ou Chrome, ils ont des débogueurs intégrés.

Vous pouvez voir la valeur dans [objet objet] comme ceci

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

Essayez comme ça

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

référence

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

Basiques

Vous ne le savez peut-être pas mais, en JavaScript, chaque fois que nous interagissons avec des chaînes, des nombres ou des primitives booléennes, nous entrons dans un monde caché d'ombres d'objets et de coercition.

string, number, boolean, null, undefined et symbol.

En JavaScript , il y a 7 types primitifs: undefined, null, boolean, string, number, bigintet symbol. Tout le reste est un objet. Les types primitifs boolean, stringet numberpeuvent être enveloppés par leurs homologues de l' objet. Ces objets sont des instances du Boolean, Stringet les Numberconstructeurs respectivement.

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"

Si les primitives n'ont pas de propriétés, pourquoi "this is a string".length renvoie-t-elle une valeur?

Parce que JavaScript contraindra facilement les primitifs et les objets. Dans ce cas, la valeur de chaîne est forcée à un objet chaîne afin d'accéder à la longueur de la propriété. L'objet string n'est utilisé que pendant une fraction de seconde, après quoi il est sacrifié aux dieux de la collecte des ordures - mais dans l'esprit des émissions de découverte télévisée, nous allons piéger la créature insaisissable et la préserver pour une analyse plus approfondie ...

Pour illustrer cela davantage, considérons l'exemple suivant dans lequel nous ajoutons une nouvelle propriété au prototype du constructeur String.

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

Par ce moyen, les primitives ont accès à toutes les propriétés (y compris les méthodes) définies par leurs constructeurs d'objets respectifs.

Nous avons donc vu que les types primitifs contraindront de manière appropriée leur homologue Object respectif si nécessaire.

Analyse de toString() méthode

Considérez le code suivant

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"

Comme discuté ci-dessus, ce qui se passe vraiment, c'est lorsque nous appelons une toString()méthode sur un type primitif, elle doit être forcée dans son homologue objet avant de pouvoir invoquer la méthode.
ie myNumber.toString()équivaut àNumber.prototype.toString.call(myNumber) et de même pour les autres types primitifs.

Mais que se passe-t-il si, au lieu que le type primitif soit passé dans la toString()méthode de son homologue de la fonction de constructeur Object correspondante, nous forçons le type primitif à être passé en tant que paramètre sur la toString()méthode du constructeur de la fonction Object ( Object.prototype.toString.call(x))?

Regardons de plus près Object.prototype.toString ()

Selon la documentation , lorsque la méthode toString est appelée, les étapes suivantes sont effectuées:

1. Si la thisvaleur est undefined, retournez "[object Undefined]".
2. Si la thisvaleur est null, retournez "[object Null]".
3. Si cette valeur n'est aucune des réponses ci-dessus, Let Oêtre le résultat de l'appel en toObjectpassant la thisvaleur comme argument.
4. Soit class la valeur de la [[Class]]propriété interne de O.
5. Renvoie la valeur de chaîne qui est le résultat de concaténer les trois cordes "[object ", classet "]".

Comprenez cela à partir de l'exemple suivant

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

Références: 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 / la-vie-secrète-des-primitives-javascript /

[object Object]est la représentation sous forme de chaîne par défaut d'un JavaScript Object. C'est ce que vous obtiendrez si vous exécutez ce code:

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

Vous pouvez modifier la représentation par défaut en remplaçant la toStringméthode comme suit:

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

Vous avez un objet javascript

$1et $2sont des objets jquery, peut-être utilisés alert($1.text());pour obtenir du texte ou alert($1.attr('id');etc ...

vous devez traiter $1et $2aimer les objets jQuery.

Vous essayez de renvoyer un objet. Comme il n'existe aucun moyen efficace de représenter un objet sous forme de chaîne, la .toString()valeur de l'objet est automatiquement définie comme "[object Object]".