¿Qué significa [objeto Objeto]?

Estoy tratando de alertar a un valor devuelto de una función y obtengo esto en la alerta:

[object Object]  

Aquí está el código 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 es la función que estoy tratando de verificar.

La conversión predeterminada de un objeto a una cadena es "[object Object]".

Como se trata de objetos jQuery, es posible que desee hacer

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

para imprimir el ID del elemento.

Como se menciona en los comentarios, debe utilizar las herramientas incluidas en navegadores como Firefox o Chrome para introspectar objetos haciendo en console.log(whichIsVisible())lugar de alert.

Nota al margen : las identificaciones no deben comenzar con dígitos.

Como han señalado otros, esta es la serialización predeterminada de un objeto. Pero por qué es [object Object]y no solo[object] ?

¡Eso es porque hay diferentes tipos de objetos en Javascript!

• Objetos de función :
  stringify(function (){})->[object Function]
• Objetos de matriz :
  stringify([])->[object Array]
• Objetos RegExp
  stringify(/x/) ->[object RegExp]
• Objetos de fecha
  stringify(new Date) ->[object Date]
• ... varios más ...
• y objetos Object !
  stringify({})->[object Object]

Eso es porque la función constructora se llama Object (con una "O" mayúscula), y el término "objeto" (con una "o" pequeña) se refiere a la naturaleza estructural de la cosa.

Por lo general, cuando se está hablando de "objetos" en Javascript, que en realidad medias " objeto objetos ", y no los otros tipos.

_{donde stringifydebería verse así:}

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

[object Object] es la representación toString predeterminada de un objeto en javascript.

Si desea conocer las propiedades de su objeto, simplemente analícelo de esta manera:

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

En su caso particular, obtiene un objeto jQuery. Intente hacer esto en su lugar:

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

Esto debería alertar a la identificación del elemento visible.

Es el valor devuelto por la toString()función de ese objeto .

Entiendo lo que intentas hacer, porque ayer respondí tu pregunta sobre cómo determinar qué div es visible. :)
La whichIsVisible()función devuelve un objeto jQuery real, porque pensé que sería más útil programáticamente . Si desea utilizar esta función con fines de depuración, puede hacer algo como esto:

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

Dicho esto, realmente debería utilizar un depurador adecuado en lugar de alert()si está intentando depurar un problema. Si está usando Firefox, Firebug es excelente. Si está utilizando IE8, Safari o Chrome, tienen depuradores integrados.

Puedes ver el valor dentro de [object Object] como este

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

Prueba así

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

referencia

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

Lo esencial

Puede que no lo sepas, pero en JavaScript, cada vez que interactuamos con cadenas, números o primitivas booleanas, entramos en un mundo oculto de sombras de objetos y coerción.

cadena, número, booleano, nulo, indefinido y símbolo.

En JavaScript hay 7 tipos primitivos: undefined, null, boolean, string, number, bigintysymbol . Todo lo demás es un objeto. Los tipos de primitivas boolean, stringy numberse pueden envolver por sus homólogos de objeto. Estos objetos son instancias de los constructores Boolean, Stringy Numberrespectivamente.

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 las primitivas no tienen propiedades, ¿por qué "this is a string".lengthdevuelven un valor?

Porque JavaScript coaccionará fácilmente entre primitivas y objetos. En este caso, el valor de la cadena se convierte en un objeto de cadena para acceder a la longitud de la propiedad. El objeto de cuerda solo se usa durante una fracción de segundo, después de lo cual se sacrifica a los dioses de la recolección de basura, pero en el espíritu de los programas de descubrimiento de televisión, atraparemos a la criatura elusiva y la conservaremos para un análisis posterior ...

Para demostrar esto, considere el siguiente ejemplo en el que estamos agregando una nueva propiedad al prototipo del constructor de cadenas.

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

De este modo, las primitivas tienen acceso a todas las propiedades (incluidos los métodos) definidas por sus respectivos constructores de objetos.

Así que vimos que los tipos primitivos coaccionarán apropiadamente a su respectiva contraparte de Objeto cuando sea necesario.

Análisis de toString() método

Considere el siguiente código

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"

Como se discutió anteriormente, lo que realmente está sucediendo es que cuando llamamos toString()a un método en un tipo primitivo, debe ser forzado a su contraparte de objeto antes de que pueda invocar el método.
es decirmyNumber.toString()es es equivalente aNumber.prototype.toString.call(myNumber) y similar a otros tipos primitivos.

Pero, ¿qué pasa si en lugar de pasar el tipo primitivo al toString()método de su correspondiente función de constructor de objetos, forzamos el tipo primitivo a pasar como parámetro al toString()método del constructor de funciones de objeto (Object.prototype.toString.call(x) )?

Un vistazo más de cerca a Object.prototype.toString ()

Según la documentación , cuando se llama al método toString, se siguen los siguientes pasos:

1. Si el thisvalor es undefined, regrese "[object Undefined]".
2. Si el thisvalor es null, regrese "[object Null]".
3. Si este valor no es ninguno de los anteriores, Osea ​​el resultado de llamar toObjectpasando elthis valor como argumento.
4. Sea class el valor de la [[Class]]propiedad interna de O.
5. Devuelve el valor de cadena que es el resultado de la concatenación de las tres cuerdas "[object ", classy "]".

Comprenda esto con el siguiente ejemplo

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

Referencias: 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-vida-secreta-de-las-primitivas-javascript /

[object Object]es la representación de cadena predeterminada de un JavaScript Object. Es lo que obtendrá si ejecuta este código:

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

Puede cambiar la representación predeterminada anulando el toStringmétodo así:

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

Tienes un objeto javascript

$1y $2son objetos jquery, tal vez se usen alert($1.text());para obtener texto o alert($1.attr('id');etc.

tienes que tratar $1y $2gustar los objetos jQuery.

Estás intentando devolver un objeto. Debido a que no existe una buena forma de representar un objeto como una cadena, el .toString()valor del objeto se establece automáticamente como "[object Object]".