Apakah ada yang setara dengan var_dump (PHP) di Javascript?

Kita perlu melihat metode / bidang apa yang dimiliki objek dalam Javascript.

Seperti yang dikatakan orang lain, Anda dapat menggunakan Firebug, dan itu tidak akan membuat Anda khawatir tentang Firefox. Chrome & Safari keduanya memiliki konsol pengembang bawaan yang memiliki antarmuka yang hampir sama dengan konsol Firebug, jadi kode Anda harus portabel di seluruh peramban itu. Untuk browser lain, ada Firebug Lite .

Jika Firebug bukan pilihan bagi Anda, cobalah skrip sederhana ini:

function dump(obj) {
    var out = '';
    for (var i in obj) {
        out += i + ": " + obj[i] + "\n";
    }

    alert(out);

    // or, if you wanted to avoid alerts...

    var pre = document.createElement('pre');
    pre.innerHTML = out;
    document.body.appendChild(pre)
}

Saya akan merekomendasikan untuk tidak memperingatkan setiap properti individu: beberapa objek memiliki BANYAK properti dan Anda akan berada di sana sepanjang hari mengklik "OK", "OK", "OK", "O ... sialan itu adalah properti saya mencari".

Jika Anda menggunakan firefox maka konsol plug-in firebug adalah cara terbaik untuk memeriksa objek

console.debug(myObject);

Atau Anda dapat mengulang-ulang properti (termasuk metode) seperti ini:

for (property in object) {
    // do what you want with property, object[property].value
}

Banyak browser modern mendukung sintaks berikut:

JSON.stringify(myVar);

Tidak dapat dinyatakan cukup bahwa Anda dapat menggunakan console.debug (objek) untuk ini. Teknik ini akan menghemat ratusan jam setahun jika Anda melakukan ini sebagai mata pencaharian: hlm

Untuk menjawab pertanyaan dari konteks judul pertanyaan ini, berikut adalah fungsi yang melakukan sesuatu yang mirip dengan PHP var_dump. Itu hanya membuang satu variabel per panggilan, tetapi itu menunjukkan tipe data serta nilai dan iterates melalui array dan objek [bahkan jika mereka Array Objek dan sebaliknya]. Saya yakin ini bisa diperbaiki. Saya lebih dari seorang pria PHP.

/**
 * Does a PHP var_dump'ish behavior.  It only dumps one variable per call.  The
 * first parameter is the variable, and the second parameter is an optional
 * name.  This can be the variable name [makes it easier to distinguish between
 * numerious calls to this function], but any string value can be passed.
 * 
 * @param mixed var_value - the variable to be dumped
 * @param string var_name - ideally the name of the variable, which will be used 
 *       to label the dump.  If this argumment is omitted, then the dump will
 *       display without a label.
 * @param boolean - annonymous third parameter. 
 *       On TRUE publishes the result to the DOM document body.
 *       On FALSE a string is returned.
 *       Default is TRUE.
 * @returns string|inserts Dom Object in the BODY element.
 */
function my_dump (var_value, var_name)
{
    // Check for a third argument and if one exists, capture it's value, else
    // default to TRUE.  When the third argument is true, this function
    // publishes the result to the document body, else, it outputs a string.
    // The third argument is intend for use by recursive calls within this
    // function, but there is no reason why it couldn't be used in other ways.
    var is_publish_to_body = typeof arguments[2] === 'undefined' ? true:arguments[2];

    // Check for a fourth argument and if one exists, add three to it and
    // use it to indent the out block by that many characters.  This argument is
    // not intended to be used by any other than the recursive call.
    var indent_by = typeof arguments[3] === 'undefined' ? 0:arguments[3]+3;

    var do_boolean = function (v)
    {
        return 'Boolean(1) '+(v?'TRUE':'FALSE');
    };

    var do_number = function(v)
    {
        var num_digits = (''+v).length;
        return 'Number('+num_digits+') '+v;
    };

    var do_string = function(v)
    {
        var num_chars = v.length;
        return 'String('+num_chars+') "'+v+'"';
    };

    var do_object = function(v)
    {
        if (v === null)
        {
            return "NULL(0)";
        }

        var out = '';
        var num_elem = 0;
        var indent = '';

        if (v instanceof Array)
        {
            num_elem = v.length;
            for (var d=0; d<indent_by; ++d)
            {
                indent += ' ';
            }
            out = "Array("+num_elem+") \n"+(indent.length === 0?'':'|'+indent+'')+"(";
            for (var i=0; i<num_elem; ++i)
            {
                out += "\n"+(indent.length === 0?'':'|'+indent)+"|   ["+i+"] = "+my_dump(v[i],'',false,indent_by);
            }
            out += "\n"+(indent.length === 0?'':'|'+indent+'')+")";
            return out;
        }
        else if (v instanceof Object)
        {
            for (var d=0; d<indent_by; ++d)
            {
                indent += ' ';
            }
            out = "Object \n"+(indent.length === 0?'':'|'+indent+'')+"(";
            for (var p in v)
            {
                out += "\n"+(indent.length === 0?'':'|'+indent)+"|   ["+p+"] = "+my_dump(v[p],'',false,indent_by);
            }
            out += "\n"+(indent.length === 0?'':'|'+indent+'')+")";
            return out;
        }
        else
        {
            return 'Unknown Object Type!';
        }
    };

    // Makes it easier, later on, to switch behaviors based on existance or
    // absence of a var_name parameter.  By converting 'undefined' to 'empty 
    // string', the length greater than zero test can be applied in all cases.
    var_name = typeof var_name === 'undefined' ? '':var_name;
    var out = '';
    var v_name = '';
    switch (typeof var_value)
    {
        case "boolean":
            v_name = var_name.length > 0 ? var_name + ' = ':''; // Turns labeling on if var_name present, else no label
            out += v_name + do_boolean(var_value);
            break;
        case "number":
            v_name = var_name.length > 0 ? var_name + ' = ':'';
            out += v_name + do_number(var_value);
            break;
        case "string":
            v_name = var_name.length > 0 ? var_name + ' = ':'';
            out += v_name + do_string(var_value);
            break;
        case "object":
            v_name = var_name.length > 0 ? var_name + ' => ':'';
            out += v_name + do_object(var_value);
            break;
        case "function":
            v_name = var_name.length > 0 ? var_name + ' = ':'';
            out += v_name + "Function";
            break;
        case "undefined":
            v_name = var_name.length > 0 ? var_name + ' = ':'';
            out += v_name + "Undefined";
            break;
        default:
            out += v_name + ' is unknown type!';
    }

    // Using indent_by to filter out recursive calls, so this only happens on the 
    // primary call [i.e. at the end of the algorithm]
    if (is_publish_to_body  &&  indent_by === 0)
    {
        var div_dump = document.getElementById('div_dump');
        if (!div_dump)
        {
            div_dump = document.createElement('div');
            div_dump.id = 'div_dump';

            var style_dump = document.getElementsByTagName("style")[0];
            if (!style_dump)
            {
                var head = document.getElementsByTagName("head")[0];
                style_dump = document.createElement("style");
                head.appendChild(style_dump);
            }
            // Thank you Tim Down [http://stackoverflow.com/users/96100/tim-down] 
            // for the following addRule function
            var addRule;
            if (typeof document.styleSheets != "undefined" && document.styleSheets) {
                addRule = function(selector, rule) {
                    var styleSheets = document.styleSheets, styleSheet;
                    if (styleSheets && styleSheets.length) {
                        styleSheet = styleSheets[styleSheets.length - 1];
                        if (styleSheet.addRule) {
                            styleSheet.addRule(selector, rule)
                        } else if (typeof styleSheet.cssText == "string") {
                            styleSheet.cssText = selector + " {" + rule + "}";
                        } else if (styleSheet.insertRule && styleSheet.cssRules) {
                            styleSheet.insertRule(selector + " {" + rule + "}", styleSheet.cssRules.length);
                        }
                    }
                };
            } else {
                addRule = function(selector, rule, el, doc) {
                    el.appendChild(doc.createTextNode(selector + " {" + rule + "}"));
                };
            }

            // Ensure the dump text will be visible under all conditions [i.e. always
            // black text against a white background].
            addRule('#div_dump', 'background-color:white', style_dump, document);
            addRule('#div_dump', 'color:black', style_dump, document);
            addRule('#div_dump', 'padding:15px', style_dump, document);

            style_dump = null;
        }

        var pre_dump = document.getElementById('pre_dump');
        if (!pre_dump)
        {
            pre_dump = document.createElement('pre');
            pre_dump.id = 'pre_dump';
            pre_dump.innerHTML = out+"\n";
            div_dump.appendChild(pre_dump);
            document.body.appendChild(div_dump);
        }  
        else
        {
            pre_dump.innerHTML += out+"\n";
        }
    }
    else
    {
        return out;
    }
}

console.dir (ke bagian bawah halaman yang ditautkan) di firebug atau google-chrome web-inspector akan menampilkan daftar interaktif dari properti objek.

Lihat juga jawaban Stack-O ini

Anda ingin melihat seluruh objek (semua level objek dan variabel di dalamnya) dalam bentuk JSON. JSON adalah singkatan dari JavaScript Object Notation, dan mencetak string JSON dari objek Anda adalah setara dengan var_dump(untuk mendapatkan representasi string dari objek JavaScript). Untungnya, JSON sangat mudah digunakan dalam kode, dan format data JSON juga cukup mudah dibaca oleh manusia.

Contoh:

var objectInStringFormat = JSON.stringify(someObject);
alert(objectInStringFormat);

Jika Anda menggunakan Firebug, Anda bisa menggunakan console.log untuk mengeluarkan objek dan mendapatkan item yang hyperlink dan mudah dieksplor di konsol.

Sedikit perbaikan pada fungsi nick untuk mereka yang tidak tahu tipe variabel yang masuk:

function dump(v) {
    switch (typeof v) {
        case "object":
            for (var i in v) {
                console.log(i+":"+v[i]);
            }
            break;
        default: //number, string, boolean, null, undefined 
            console.log(typeof v+":"+v);
            break;
    }
}

Saya meningkatkan jawaban nick, sehingga secara berulang loop melalui objek:

function var_dump(obj, element)
{
    var logMsg = objToString(obj, 0);
    if (element) // set innerHTML to logMsg
    {
        var pre = document.createElement('pre');
        pre.innerHTML = logMsg;
        element.innerHTML = '';
        element.appendChild(pre);
    }
    else // write logMsg to the console
    {
        console.log(logMsg);
    }
}

function objToString(obj, level)
{
    var out = '';
    for (var i in obj)
    {
        for (loop = level; loop > 0; loop--)
        {
            out += "    ";
        }
        if (obj[i] instanceof Object)
        {
            out += i + " (Object):\n";
            out += objToString(obj[i], level + 1);
        }
        else
        {
            out += i + ": " + obj[i] + "\n";
        }
    }
    return out;
}

console.log(OBJECT|ARRAY|STRING|...);
console.info(OBJECT|ARRAY|STRING|...);
console.debug(OBJECT|ARRAY|STRING|...);
console.warn(OBJECT|ARRAY|STRING|...);
console.assert(Condition, 'Message if false');

Ini harus bekerja dengan benar di Google Chrome dan Mozilla Firefox (jika Anda menjalankan dengan versi firefox lama, jadi Anda harus menginstal plugin Firebug)
Di Internet Explorer 8 atau lebih tinggi Anda harus melakukan hal berikut:

• Luncurkan "Alat Pengembang, dengan mengklik Tombol F12
• Pada Daftar Tab, klik pada "Script" Tab "
• Klik pada tombol "Konsol" di sebelah kanan

Untuk informasi lebih lanjut, Anda dapat mengunjungi URL ini: https://developer.chrome.com/devtools/docs/console-api

Anda cukup menggunakan paket NPM var_dump

npm install var_dump --save-dev

Pemakaian:

const var_dump = require('var_dump')

var variable = {
  'data': {
    'users': {
      'id': 12,
      'friends': [{
        'id': 1,
        'name': 'John Doe'
      }]
    }
  }
}

// print the variable using var_dump
var_dump(variable)

Ini akan mencetak:

object(1) {
    ["data"] => object(1) {
        ["users"] => object(2) {
            ["id"] => number(12)
            ["friends"] => array(1) {
                [0] => object(2) {
                    ["id"] => number(1)
                    ["name"] => string(8) "John Doe"
                }
            }
        }
    }
}

Tautan: https://www.npmjs.com/package/@smartankur4u/vardump

Terima kasih nanti!

Jika Anda mencari fungsi PHP yang dikonversi dalam JS, ada situs kecil ini: http://phpjs.org . Di sana Anda bisa mendapatkan sebagian besar fungsi PHP andal ditulis dalam JS. untuk var_dump coba: http://phpjs.org/functions/var_dump/ (pastikan untuk memeriksa komentar teratas, ini tergantung pada "echo", yang juga dapat diunduh dari situs yang sama)

Saya menggunakan jawaban pertama, tetapi saya merasa ada rekursi yang hilang.

Hasilnya adalah ini:

function dump(obj) {
    var out = '';
    for (var i in obj) {
        if(typeof obj[i] === 'object'){
            dump(obj[i]);
        }else{
            out += i + ": " + obj[i] + "\n";
        }
    }

    var pre = document.createElement('pre');
    pre.innerHTML = out;
    document.body.appendChild(pre);
}

Berdasarkan fungsi sebelumnya yang ditemukan di posting ini. Menambahkan mode rekursif dan indentasi.

function dump(v, s) {
  s = s || 1;
  var t = '';
  switch (typeof v) {
    case "object":
      t += "\n";
      for (var i in v) {
        t += Array(s).join(" ")+i+": ";
        t += dump(v[i], s+3);
      }
      break;
    default: //number, string, boolean, null, undefined 
      t += v+" ("+typeof v+")\n";
      break;
  }
  return t;
}

Contoh

var a = {
  b: 1,
  c: {
    d:1,
    e:2,
    d:3,
    c: {
      d:1,
      e:2,
      d:3
    }
  }
};

var d = dump(a);
console.log(d);
document.getElementById("#dump").innerHTML = "<pre>" + d + "</pre>";

Hasil

b: 1 (number)
c: 
   d: 3 (number)
   e: 2 (number)
   c: 
      d: 3 (number)
      e: 2 (number)

Berikut ini adalah setara var_dump / print_r favorit saya di Javascript ke PHP var_dump.

 function dump(arr,level) {
  var dumped_text = "";
  if(!level) level = 0;

  //The padding given at the beginning of the line.
  var level_padding = "";
  for(var j=0;j<level+1;j++) level_padding += "    ";

  if(typeof(arr) == 'object') { //Array/Hashes/Objects 
   for(var item in arr) {
    var value = arr[item];

    if(typeof(value) == 'object') { //If it is an array,
     dumped_text += level_padding + "'" + item + "' ...\n";
     dumped_text += dump(value,level+1);
    } else {
     dumped_text += level_padding + "'" + item + "' => \"" + value + "\"\n";
    }
   }
  } else { //Stings/Chars/Numbers etc.
   dumped_text = "===>"+arr+"<===("+typeof(arr)+")";
  }
  return dumped_text;
 }

Terlambat dalam permainan, tetapi inilah fungsi yang sangat praktis yang super mudah digunakan, memungkinkan Anda untuk meloloskan sebanyak mungkin argumen dari jenis apa pun, dan akan menampilkan konten objek di jendela konsol browser seolah-olah Anda disebut konsol. log dari JavaScript - tetapi dari PHP

Catatan, Anda dapat menggunakan tag juga dengan melewati 'TAG-YourTag' dan itu akan diterapkan hingga tag lain dibaca, misalnya, 'TAG-YourNextTag'

/*
*   Brief:          Print to console.log() from PHP
*   Description:    Print as many strings,arrays, objects, and other data types to console.log from PHP.
*                   To use, just call consoleLog($data1, $data2, ... $dataN) and each dataI will be sent to console.log - note that
*                   you can pass as many data as you want an this will still work.
*
*                   This is very powerful as it shows the entire contents of objects and arrays that can be read inside of the browser console log.
*                   
*                   A tag can be set by passing a string that has the prefix TAG- as one of the arguments. Everytime a string with the TAG- prefix is
*                   detected, the tag is updated. This allows you to pass a tag that is applied to all data until it reaches another tag, which can then
*                   be applied to all data after it.
*
*                   Example:
*                   consoleLog('TAG-FirstTag',$data,$data2,'TAG-SecTag,$data3); 
*                   Result:
*                       FirstTag '...data...'
*                       FirstTag '...data2...'
*                       SecTag   '...data3...' 
*/
function consoleLog(){
    if(func_num_args() == 0){
        return;
    }

    $tag = '';
    for ($i = 0; $i < func_num_args(); $i++) {
        $arg = func_get_arg($i);
        if(!empty($arg)){       
            if(is_string($arg)&& strtolower(substr($arg,0,4)) === 'tag-'){
                $tag = substr($arg,4);
            }else{      
                $arg = json_encode($arg, JSON_HEX_TAG | JSON_HEX_AMP );
                echo "<script>console.log('".$tag." ".$arg."');</script>";
            }       
        }
    }
}

CATATAN: func_num_args () dan func_num_args () adalah fungsi php untuk membaca sejumlah input arg yang dinamis, dan memungkinkan fungsi ini memiliki banyak permintaan console.log tak terhingga dari satu panggilan fungsi