O que significa [objeto Objeto]?

Estou tentando alertar um valor retornado de uma função e recebo o seguinte no alerta:

[object Object]  

Aqui está o 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 é a função que estou tentando verificar.

A conversão padrão de um objeto em string é "[object Object]".

Como você está lidando com objetos jQuery, você pode querer fazer

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

para imprimir o ID do elemento.

Conforme mencionado nos comentários, você deve usar as ferramentas incluídas em navegadores como Firefox ou Chrome para introspectar objetos fazendo em console.log(whichIsVisible())vez de alert.

Nota lateral : IDs não devem começar com dígitos.

Como outros observaram, esta é a serialização padrão de um objeto. Mas por que é [object Object]e não justo [object]?

Isso ocorre porque existem diferentes tipos de objetos em Javascript!

• Objetos de função :
  stringify(function (){})->[object Function]
• Objetos Array :
  stringify([])->[object Array]
• Objetos RegExp
  stringify(/x/) ->[object RegExp]
• Objetos de data
  stringify(new Date) ->[object Date]
• ... vários mais ...
• e objetos Object !
  stringify({})->[object Object]

Isso ocorre porque a função construtora é chamada Object(com "O" maiúsculo), e o termo "objeto" (com "o" minúsculo) se refere à natureza estrutural da coisa.

Normalmente, quando você está falando sobre "objetos" em Javascript, você realmente quer dizer " Objetos ", e não os outros tipos.

_{onde stringifydeve ficar assim:}

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

[object Object] é a representação toString padrão de um objeto em javascript.

Se você quiser saber as propriedades do seu objeto, basta falar sobre ele assim:

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

Em seu caso específico, você está obtendo um objeto jQuery. Tente fazer isso:

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

Isso deve alertar o id do elemento visível.

É o valor retornado pela toString()função desse objeto .

Eu entendo o que você está tentando fazer, porque respondi à sua pergunta ontem sobre como determinar qual div é visível. :)
A whichIsVisible()função retorna um objeto jQuery real, porque pensei que seria mais útil programaticamente . Se quiser usar essa função para fins de depuração, você pode simplesmente fazer algo assim:

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

Dito isso, você realmente deve usar um depurador adequado em vez de alert()tentar depurar um problema. Se você estiver usando o Firefox, o Firebug é excelente. Se você estiver usando o IE8, Safari ou Chrome, eles têm depuradores integrados.

Você pode ver o valor dentro de [objeto Object] como este

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

Tente assim

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

referência

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

Fundamentos

Você pode não saber, mas, em JavaScript, sempre que interagimos com strings, números ou primitivos booleanos, entramos em um mundo oculto de sombras de objetos e coerção.

string, número, booleano, nulo, indefinido e símbolo.

Em JavaScript existem 7 tipos primitivos: undefined, null, boolean, string, number, biginte symbol. Tudo o mais é um objeto. Os tipos de primitivas boolean, stringe numberpode ser enrolada por objeto os seus homólogos. Esses objetos são instâncias doBoolean , Stringe Numberconstrutores, respectivamente.

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"

Se os primitivos não têm propriedades, por que "this is a string".lengthretorna um valor?

Porque JavaScript irá coagir prontamente entre primitivos e objetos. Neste caso, o valor da string é forçado a um objeto string para acessar o comprimento da propriedade. O objeto de corda é usado apenas por uma fração de segundo após o qual é sacrificado aos Deuses da coleta de lixo - mas no espírito dos programas de descoberta de TV, vamos prender a criatura evasiva e preservá-la para análise posterior ...

Para demonstrar isso, considere o exemplo a seguir, no qual estamos adicionando uma nova propriedade ao protótipo do construtor String.

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

Desta forma, as primitivas têm acesso a todas as propriedades (incluindo métodos) definidas por seus respectivos construtores de objetos.

Assim, vimos que os tipos primitivos irão forçar apropriadamente a sua contraparte do Objeto quando necessário.

Análise do toString()método

Considere o seguinte 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"

Conforme discutido acima, o que realmente está acontecendo é que, quando chamamos o toString()método em um tipo primitivo, ele precisa ser coagido em sua contraparte de objeto antes de poder invocar o método.
ou seja, myNumber.toString()é equivalente aNumber.prototype.toString.call(myNumber) e similar para outros tipos primitivos.

Mas e se em vez de o tipo primitivo ser passado para o toString()método de sua contraparte de função de construtor de Object correspondente, forçarmos o tipo primitivo a ser passado como parâmetro para o toString()método de construtor de função de Object ( Object.prototype.toString.call(x))?

Olhe mais de perto em Object.prototype.toString ()

De acordo com a documentação , quando o método toString é chamado, as seguintes etapas são executadas:

1. Se o thisvalor for undefined, retorne "[object Undefined]".
2. Se o thisvalor for null, retorne "[object Null]".
3. Se este valor não for nenhum dos anteriores, Let Oser o resultado da chamada toObjectpassando o thisvalor como o argumento.
4. Seja class o valor da [[Class]]propriedade interna de O.
5. Devolver o valor de cadeia que é o resultado da concatenação das três cordas "[object ", classe "]".

Entenda isso com o exemplo a seguir

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

Referências: 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 / the-secret-life-of-javascript-primitives /

[object Object]é a representação de string padrão de um JavaScript Object. É o que você obterá se executar este código:

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

Você pode alterar a representação padrão substituindo o toStringmétodo da seguinte maneira:

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

Você tem um objeto javascript

$1e $2são objetos jquery, talvez usados alert($1.text());para obter texto ou alert($1.attr('id');etc ...

você tem que tratar $1e $2gostar de objetos jQuery.

Você está tentando retornar um objeto. Como não existe uma boa maneira de representar um objeto como uma string, o .toString()valor do objeto é automaticamente definido como "[object Object]".