Usar o método nativo JSON.stringify. Funciona com objetos aninhados e todos os navegadores principais suportam este método.

str = JSON.stringify(obj);
str = JSON.stringify(obj, null, 4); // (Optional) beautiful indented output.
console.log(str); // Logs output to dev tools console.
alert(str); // Displays output using window.alert()

Ligação a referência da API Mozilla e outros exemplos.

obj = JSON.parse(str); // Reverses above operation (Just in case if needed.)

Use um personalizado JSON.stringify replacer se encontrar este erro de Javascript

"Uncaught TypeError: Converting circular structure to JSON"

var output = '';
for (var property in object) {
  output += property + ': ' + object[property]+'; ';
}
alert(output);

console.dir(object):

Mostra uma lista interactiva das propriedades de um objecto JavaScript especificado. Esta lista permite-lhe usar triângulos de divulgação para examinar o conteúdo dos objectos-filhos.

Note que a funcionalidade console.dir() não é normal. Ver documentos web MDN

Tenta isto:

console.log(JSON.stringify(obj))

Isto irá imprimir a versão de stringify do objecto. Então, em vez de [object] como uma saída, você vai obter o conteúdo do objeto.

Se quiser usar o alert, para imprimir o seu objecto, pode fazer isto:

alert("myObject is " + myObject.toSource());

Deve imprimir cada propriedade e o seu valor correspondente no formato de texto.

Se quiser ver os dados em formato tabular, pode usar

console.table(obj);

A tabela pode ser ordenada se clicar na coluna da tabela.

Também pode seleccionar as colunas a mostrar:

console.table(obj, ['firstName', 'lastName']);

Você pode encontrar mais informações sobre o console.Quadro Aqui

Em NodeJS você pode imprimir um objecto usando util.inspect(obj). Certifique-se de indicar a profundidade ou você só terá uma impressão superficial do objeto.

Função:

var print = function(o){
    var str='';

    for(var p in o){
        if(typeof o[p] == 'string'){
            str+= p + ': ' + o[p]+'; </br>';
        }else{
            str+= p + ': { </br>' + print(o[p]) + '}';
        }
    }

    return str;
}

Utilização:

var myObject = {
    name: 'Wilson Page',
    contact: {
        email: '[email protected]',
        tel: '123456789'
    }  
}

$('body').append( print(myObject) );

Exemplo:

Http://jsfiddle.net/WilsonPage/6eqMn/

Basta utilizar

JSON.stringify(obj)

Exemplo

var args_string = JSON.stringify(obj);
console.log(args_string);

Ou

alert(args_string);

Também, nota em funções javascript são considerados como objetos.

Como nota extra:

foo.moo = "stackoverflow";
console.log(foo.moo);
alert(foo.moo);

NB: Nestes exemplos, yourObj define o objeto que você quer examinar.

Em primeiro lugar, a minha forma menos favorita, mas mais utilizada, de mostrar um objecto:

Esta é a maneira defacto de mostrar o conteúdo de um objeto

console.log(yourObj)

Produzirá algo como :

Acho que a melhor solução é olhar através das teclas dos objectos, e depois através dos valores dos objectos, se realmente quiser ver qual é o objecto retencao...

console.log(Object.keys(yourObj));
console.log(Object.values(yourObj));

Vai produzir algo como : (ilustrado acima: as chaves/valores guardados no objecto)

Existe também esta nova opção se estiver a utilizar o ECMAScript 2016 ou mais recente:

Object.keys(yourObj).forEach(e => console.log(`key=${e}  value=${yourObj[e]}`));

Isto produzirá uma boa produção. : A solução mencionada numa resposta anterior: console.log(yourObj) mostra demasiados parâmetros e não é a forma mais amigável de mostrar os dados que deseja. É por isso que eu recomendo chaves de registro e, em seguida, valores separadamente.

console.table(yourObj)

Usa isto:

console.log('print object: ' + JSON.stringify(session));

var getPrintObject=function(object)
{
    return JSON.stringify(object);
}

Para imprimir o objecto completo com o nó .JS com cores como bónus:

console.dir(object, {depth: null, colors: true})

As cores são naturalmente opcionais, 'depth: null' irá imprimir o objecto completo.

As opções não parecem ser suportadas nos navegadores.

Referências:

Https://developer.mozilla.org/en-US/docs/Web/API/Console/dir

Https://nodejs.org/api/console.html#console_console_dir_obj_options

Se quiser imprimir o objecto de todo o seu comprimento, pode usar

Consola.log (require ('util').inspeccionar (obj, {showHidden: false, depth: null})

Se quiser imprimir o objecto convertendo-o para o texto então

Consola.log (JSON.stringify (obj);

(isto foi adicionado à Minha Biblioteca no GitHub.)

De qualquer forma, o resultado desta função será uma representação de cadeia de caracteres do seu objecto, mesmo que o seu objecto tenha objectos e arrays incorporados, e mesmo que esses objectos ou arrays tenham ainda mais objectos e arrays incorporados. Ouvi dizer que gostas de beber? Então, eu chulei o teu carro com uma geleira. E depois, eu chulei a tua geleira com uma geleira. Então, a tua geleira pode beber, enquanto estás a ser fixe.)

As matrizes são armazenadas com [] em vez de {} e, portanto, não têm pares chave/valor, apenas valores. Como arrays normais. Por isso, eles são criados como arrays fazer.

Além disso, todas as cadeias de caracteres (incluindo os nomes das chaves) são citadas, isto não é necessário a menos que essas cadeias de caracteres tenham caracteres especiais (como um espaço ou uma barra). Mas, não me apeteceu detectar isto só para remover algumas citações que de outra forma ainda funcionariam bem.

Este texto resultante pode então ser usado com eval ou simplesmente despejá-lo numa manipulação de cordas var Tru. Assim, recriando seu objeto novamente, a partir do texto.

function ObjToSource(o){
    if (!o) return 'null';
    var k="",na=typeof(o.length)=="undefined"?1:0,str="";
    for(var p in o){
        if (na) k = "'"+p+ "':";
        if (typeof o[p] == "string") str += k + "'" + o[p]+"',";
        else if (typeof o[p] == "object") str += k + ObjToSource(o[p])+",";
        else str += k + o[p] + ",";
    }
    if (na) return "{"+str.slice(0,-1)+"}";
    else return "["+str.slice(0,-1)+"]";
}

Editar: verificação adicionada para os objectos de valor nulo. Obrigado Brock Adams.

Editar: abaixo está a função fixa para ser capaz de imprimir objetos infinitamente recursivos. Isto não imprime o mesmo que toSource de FF porque toSource irá imprimir a recursão infinita uma vez, onde como, esta função irá matá-la imediatamente. Esta função é mais lenta do que a anterior, por isso vou adicioná-la aqui. em vez de editar a função acima, como sua única necessidade Se você planeja passar objetos que ligam de volta para si mesmos, em algum lugar.

const ObjToSource=(o)=> {
    if (!o) return null;
    let str="",na=0,k,p;
    if (typeof(o) == "object") {
        if (!ObjToSource.check) ObjToSource.check = new Array();
        for (k=ObjToSource.check.length;na<k;na++) if (ObjToSource.check[na]==o) return '{}';
        ObjToSource.check.push(o);
    }
    k="",na=typeof(o.length)=="undefined"?1:0;
    for(p in o){
        if (na) k = "'"+p+"':";
        if (typeof o[p] == "string") str += k+"'"+o[p]+"',";
        else if (typeof o[p] == "object") str += k+ObjToSource(o[p])+",";
        else str += k+o[p]+",";
    }
    if (typeof(o) == "object") ObjToSource.check.pop();
    if (na) return "{"+str.slice(0,-1)+"}";
    else return "["+str.slice(0,-1)+"]";
}

Teste:

var test1 = new Object();
test1.foo = 1;
test1.bar = 2;

var testobject = new Object();
testobject.run = 1;
testobject.fast = null;
testobject.loop = testobject;
testobject.dup = test1;

console.log(ObjToSource(testobject));
console.log(testobject.toSource());

{'run':1,'fast':null,'loop':{},'dup':{'foo':1,'bar':2}}
({run:1, fast:null, loop:{run:1, fast:null, loop:{}, dup:{foo:1, bar:2}}, dup:{foo:1, bar:2}})

console.log("%o", obj);

Eu precisava de uma maneira de imprimir recursivamente o objeto, que a resposta de pagewil forneceu (obrigado!). Eu atualizei um pouco para incluir uma maneira de imprimir até um certo nível, e para adicionar espaçamento para que ele seja devidamente indentado com base no nível atual em que estamos, de modo que fica mais legível.

// Recursive print of object
var print = function( o, maxLevel, level ) {
    if ( typeof level == "undefined" ) {
        level = 0;
    }
    if ( typeof level == "undefined" ) {
        maxLevel = 0;
    }

    var str = '';
    // Remove this if you don't want the pre tag, but make sure to remove
    // the close pre tag on the bottom as well
    if ( level == 0 ) {
        str = '<pre>';
    }

    var levelStr = '';
    for ( var x = 0; x < level; x++ ) {
        levelStr += '    ';
    }

    if ( maxLevel != 0 && level >= maxLevel ) {
        str += levelStr + '...</br>';
        return str;
    }

    for ( var p in o ) {
        if ( typeof o[p] == 'string' ) {
            str += levelStr +
                p + ': ' + o[p] + ' </br>';
        } else {
            str += levelStr +
                p + ': { </br>' + print( o[p], maxLevel, level + 1 ) + levelStr + '}</br>';
        }
    }

    // Remove this if you don't want the pre tag, but make sure to remove
    // the open pre tag on the top as well
    if ( level == 0 ) {
        str += '</pre>';
    }
    return str;
};

Utilização:

var pagewilsObject = {
    name: 'Wilson Page',
    contact: {
        email: '[email protected]',
        tel: '123456789'
    }  
}

// Recursive of whole object
$('body').append( print(pagewilsObject) ); 

// Recursive of myObject up to 1 level, will only show name 
// and that there is a contact object
$('body').append( print(pagewilsObject, 1) ); 

Você também pode usar o conceito literal de modelo ES6 para mostrar o conteúdo de um objeto JavaScript em um formato de texto.

alert(`${JSON.stringify(obj)}`);

const obj  = {
  "name" : "John Doe",
  "habbits": "Nothing",
};
alert(`${JSON.stringify(obj)}`);

Uso sempre console.log("object will be: ", obj, obj1). assim não preciso de trabalhar com o stringify com o JSON. Todas as propriedades do objeto serão expandidas bem.

Outra forma de mostrar os objectos dentro da consola é com JSON.stringify. Confira o exemplo abaixo:

var gandalf = {
  "real name": "Gandalf",
  "age (est)": 11000,
  "race": "Maia",
  "haveRetirementPlan": true,
  "aliases": [
    "Greyhame",
    "Stormcrow",
    "Mithrandir",
    "Gandalf the Grey",
    "Gandalf the White"
  ]
};
//to console log object, we cannot use console.log("Object gandalf: " + gandalf);
console.log("Object gandalf: ");
//this will show object gandalf ONLY in Google Chrome NOT in IE
console.log(gandalf);
//this will show object gandalf IN ALL BROWSERS!
console.log(JSON.stringify(gandalf));
//this will show object gandalf IN ALL BROWSERS! with beautiful indent
console.log(JSON.stringify(gandalf, null, 4));

Função Javascript

<script type="text/javascript">
    function print_r(theObj){ 
       if(theObj.constructor == Array || theObj.constructor == Object){ 
          document.write("<ul>") 
          for(var p in theObj){ 
             if(theObj[p].constructor == Array || theObj[p].constructor == Object){ 
                document.write("<li>["+p+"] => "+typeof(theObj)+"</li>"); 
                document.write("<ul>") 
                print_r(theObj[p]); 
                document.write("</ul>") 
             } else { 
                document.write("<li>["+p+"] => "+theObj[p]+"</li>"); 
             } 
          } 
          document.write("</ul>") 
       } 
    } 
</script>

Objecto De Impressão

<script type="text/javascript">
print_r(JAVACRIPT_ARRAY_OR_OBJECT);
</script> 

Via print_r em Javascript

var list = function(object) {
   for(var key in object) {
     console.log(key);
   }
}

Onde object está o teu objecto

Ou pode usar isto nas Ferramentas do dev do chrome, página "consola":

console.log(object);

Assume o objecto obj = {0:'John', 1:'Foo', 2:'Bar'}

Imprimir o conteúdo do objecto

for (var i in obj){
    console.log(obj[i], i);
}

Saída da consola (DevTools Chrome):

John 0
Foo 1
Bar 2

Prefiro usar console.table para obter um formato de objecto claro, por isso imagine que tem este objecto:

const obj = {name: 'Alireza', family: 'Dezfoolian', gender: 'male', netWorth: "$0"};

E você vai ver uma tabela limpa e legível como esta abaixo:

Uma pequena função auxiliar que uso sempre nos meus projectos para depuração rápida e simples através da consola. Inspiração tirada de Laravel.

/**
 * @param variable mixed  The var to log to the console
 * @param varName string  Optional, will appear as a label before the var
 */
function dd(variable, varName) {
    var varNameOutput;

    varName = varName || '';
    varNameOutput = varName ? varName + ':' : '';

    console.warn(varNameOutput, variable, ' (' + (typeof variable) + ')');
}

Utilização

dd(123.55); resultados:

var obj = {field1: 'xyz', field2: 2016};
dd(obj, 'My Cool Obj'); 

Se estás à procura de uma linha interna para o nó.js...

console.log("%o", object);

Aqui está a minha versão ligeiramente alargada com travessões (desleixados) e delimitadores prop/ob distintos:

var print = function(obj, delp, delo, ind){
    delp = delp!=null ? delp : "\t"; // property delimeter
    delo = delo!=null ? delo : "\n"; // object delimeter
    ind = ind!=null ? ind : " "; // indent; ind+ind geometric addition not great for deep objects
    var str='';

    for(var prop in obj){
        if(typeof obj[prop] == 'string' || typeof obj[prop] == 'number'){
          var q = typeof obj[prop] == 'string' ? "" : ""; // make this "'" to quote strings
          str += ind + prop + ': ' + q + obj[prop] + q + '; ' + delp;
        }else{
          str += ind + prop + ': {'+ delp + print(obj[prop],delp,delo,ind+ind) + ind + '}' + delo;
        }
    }
    return str;
};

Outra modificação do código de pagewils... ele não imprime nada além de cordas e deixa o número e campos booleanos em branco e eu corrigi o erro no segundo tipo apenas dentro da função criada por megaboss.

var print = function( o, maxLevel, level )
{
    if ( typeof level == "undefined" )
    {
        level = 0;
    }
    if ( typeof maxlevel == "undefined" )
    {
        maxLevel = 0;
    }

    var str = '';
    // Remove this if you don't want the pre tag, but make sure to remove
    // the close pre tag on the bottom as well
    if ( level == 0 )
    {
        str = '<pre>';   // can also be <pre>
    }

    var levelStr = '<br>';
    for ( var x = 0; x < level; x++ )
    {
        levelStr += '    ';   // all those spaces only work with <pre>
    }

    if ( maxLevel != 0 && level >= maxLevel )
    {
        str += levelStr + '...<br>';
        return str;
    }

    for ( var p in o )
    {
        switch(typeof o[p])
        {
          case 'string':
          case 'number':    // .tostring() gets automatically applied
          case 'boolean':   // ditto
            str += levelStr + p + ': ' + o[p] + ' <br>';
            break;

          case 'object':    // this is where we become recursive
          default:
            str += levelStr + p + ': [ <br>' + print( o[p], maxLevel, level + 1 ) + levelStr + ']</br>';
            break;
        }
    }

    // Remove this if you don't want the pre tag, but make sure to remove
    // the open pre tag on the top as well
    if ( level == 0 )
    {
        str += '</pre>';   // also can be </pre>
    }
    return str;
};