Есть ли эквивалент для var_dump (PHP) в Javascript?

Если вы используете firefox, то консоль плагин firebug - отличный способ исследования объектов.

console.debug(myObject);

В качестве альтернативы вы можете просмотреть свойства (включая методы) следующим образом:

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

Если вы используете Firebug, вы можете использовать console.info для вывода объекта и получения гиперссылки, доступного для изучения элемента в консоли.

Как говорили другие, вы можете использовать Firebug, и это избавит вас от проблем с Firefox. У Chrome и Safari есть встроенная консоль разработчика, интерфейс которой практически идентичен интерфейсу консоли Firebug, поэтому ваш код должен быть переносимым в эти браузеры. Для других браузеров есть Firebug Lite.

Если Firebug вам не подходит, попробуйте этот простой скрипт:

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

Я бы не рекомендовал предупреждать каждое отдельное свойство: некоторые объекты имеют МНОГО свойств, и вы будете там весь день, нажимая «ОК», «ОК», «ОК», «О ... черт возьми, это было свойство, которым я был находясь в поиске".

Нельзя сказать достаточно, что вы можете использовать console.debug (object) для этого. Этот метод сэкономит вам буквально сотни часов в год, если вы будете этим зарабатывать на жизнь: p

Многие современные браузеры поддерживают следующий синтаксис:

JSON.stringify(myVar);

console.dir (в нижней части связанной страницы) либо в firebug, либо в веб-инспекторе google-chrome выведет интерактивный список свойств объекта.

См. Также этот ответ Stack-O

Небольшое улучшение функции nickf для тех, кто не знает тип входящей переменной:

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

Я улучшил ответ nickf, поэтому он рекурсивно перебирает объекты:

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.info(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;
}

Чтобы ответить на вопрос из контекста заголовка этого вопроса, вот функция, которая делает что-то похожее на PHP var_dump. Он выгружает только одну переменную за вызов, но указывает тип данных, а также значение, и выполняет итерацию по массивам и объектам [даже если они являются массивами объектов и наоборот]. Я уверен, что это можно улучшить. Я больше сторонник 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;
    }
}

Если вы ищете функцию PHP, преобразованную в JS, есть этот небольшой сайт: http://phpjs.org. Там вы можете получить большую часть функций PHP, надежно написанных на JS. для var_dump попробуйте: http://phpjs.org/functions/var_dump/ (обязательно проверьте верхний комментарий, это зависит от "echo", которое также можно скачать с того же сайта)

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

Они должны работать правильно в Google Chrome и Mozilla Firefox (если вы используете старую версию firefox, поэтому вам необходимо установить плагин Firebug)
В Internet Explorer 8 или выше вы должны сделать следующее:

• Запустите "Инструменты разработчика", нажав кнопку F12.
• В списке вкладок щелкните вкладку «Сценарий».
• Нажмите кнопку "Консоль" справа.

Для получения дополнительной информации вы можете посетить этот URL: https://developer.chrome.com/devtools/docs/console-api

Я использовал первый ответ, но мне показалось, что в нем отсутствует рекурсия.

Результат был такой:

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

На основе предыдущих функций, найденных в этом посте. Добавлен рекурсивный режим и отступ.

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

Пример

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

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

Результат

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

Вы хотите увидеть весь объект (все уровни вложенности объектов и переменных внутри него) в форме JSON. JSON означает нотацию объектов JavaScript, и печать строки JSON вашего объекта является хорошим эквивалентом var_dump (для получения строкового представления объекта JavaScript). К счастью, JSON очень легко использовать в коде, и формат данных JSON также довольно удобочитаем.

Пример:

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

Ниже приведен мой любимый эквивалент var_dump / print_r в Javascript для 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;
}

Поздно в игре, но вот действительно удобная функция, которая очень проста в использовании, позволяет передавать столько аргументов, сколько захотите, любого типа и отображает содержимое объекта в окне консоли браузера, как если бы вы вызывали console. логировать из JavaScript - но из PHP

Обратите внимание: вы также можете использовать теги, передав 'TAG-YourTag', и он будет применяться до тех пор, пока не будет прочитан другой тег, например, 'TAG-YourNextTag'

/*
*   Brief:          Print to console.info() from PHP
*   Description:    Print as many strings,arrays, objects, and other data types to console.info from PHP.
*                   To use, just call consoleLog($data1, $data2, ... $dataN) and each dataI will be sent to console.info - 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.info('".$tag." ".$arg."');</script>";
            }       
        }
    }
}

ПРИМЕЧАНИЕ: func_num_args () и func_num_args () - это функции php для чтения динамического числа входных аргументов, которые позволяют этой функции иметь бесконечно много запросов console.info из одного вызова функции.

Вы можете просто использовать пакет NPM var_dump

npm install var_dump --save-dev

Использование:

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)

Это напечатает:

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

Ссылка: https://www.npmjs.com/package/@smartankur4u/vardump

Отблагодаришь позже!

Вот мое решение. Он хорошо воспроизводит поведение var_dump и позволяет использовать вложенные объекты / массивы. Обратите внимание, что он не поддерживает несколько аргументов.

function var_dump(variable) {
  let out = "";
  
  let type = typeof variable;
  if (type == "object") {
    var realType;
    var length;
    if (variable instanceof Array) {
      realType = "array";
      length = variable.length;
    } else {
      realType = "object";
      length = Object.keys(variable).length;
    }
    out = `${realType}(${length}) {`;
      for (const [key, value] of Object.entries(variable)) {
    out += `\n [${key}]=>\n ${var_dump(value).replace(/\n/g, "\n  ")}\n`;
  }
  out += "}";
  } else if (type == "string") {
    out = `${type}(${type.length}) "${variable}"`;
  } else {
    out = `${type}(${variable.toString()})`;
  }
  return out;
}
console.info(var_dump(1.5));
console.info(var_dump("Hello!"));
console.info(var_dump([]));
console.info(var_dump([1,2,3,[1,2]]));

console.info(var_dump({"a":"b"}));