Existe-t-il un équivalent pour var_dump (PHP) en Javascript?
Nous avons besoin de voir quelles méthodes/champs un objet a en Javascript.
Comme les autres l'ont dit, vous pouvez utiliser Firebug, et cela ne vous réglera aucun souci sur Firefox. Chrome et Safari disposent tous deux d'une console de développement intégrée dotée d'une interface presque identique à celle de Firebug. Votre code doit donc être portable sur tous ces navigateurs. Pour les autres navigateurs, il y a Firebug Lite .
Si Firebug n'est pas une option pour vous, essayez ce script simple:
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)
}
Je recommande de ne pas alerter chaque propriété individuelle: certains objets ont BEAUCOUP de propriétés et vous serez là toute la journée en cliquant sur "OK", "OK", "OK", "O ... putain c'était la propriété que j'étais à la recherche de".
Si vous utilisez firefox, le firebug plug-in console est un excellent moyen d'examiner les objets.
console.debug(myObject);
Sinon, vous pouvez parcourir les propriétés (y compris les méthodes) comme ceci:
for (property in object) {
// do what you want with property, object[property].value
}
Beaucoup de navigateurs modernes supportent la syntaxe suivante:
JSON.stringify(myVar);
On ne peut pas dire assez que vous pouvez utiliser console.debug (objet) pour cela. Si vous faites cela pour gagner votre vie, cette technique vous fera économiser littéralement des centaines d’heures par an: p
Pour répondre à la question à partir du titre du titre de cette question, voici une fonction faisant quelque chose de similaire à un PHP var_dump. Il ne vide qu'une variable par appel, mais il indique le type de données ainsi que la valeur et itère entre tableaux et objets [même s'il s'agit de tableaux d'objets et inversement]. Je suis sûr que cela peut être amélioré. Je suis plus d'un PHP gars.
/**
* 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 (vers le bas de la page liée) dans firebug ou dans l'inspecteur Web Google-Chrome génère une liste interactive des propriétés d'un objet.
Voir aussi cette réponse de Stack-O
Vous voulez voir l'objet entier (tous les niveaux imbriqués d'objets et de variables à l'intérieur) sous forme JSON. JSON signifie JavaScript Object Notation, et imprimer une chaîne JSON de votre objet équivaut à var_dump (pour obtenir une représentation sous forme de chaîne d'un objet JavaScript). Heureusement, JSON est très facile à utiliser dans le code et le format de données JSON est également assez lisible par l'homme.
Exemple:
var objectInStringFormat = JSON.stringify(someObject);
alert(objectInStringFormat);
Si vous utilisez Firebug, vous pouvez utiliser console.log pour générer un objet et obtenir un élément explicable lié à un lien dans la console.
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');
Ceux-ci devraient fonctionner correctement sur Google Chrome et Mozilla Firefox (si vous utilisez une ancienne version de Firefox, vous devez donc installer le plugin Firebug).
Sur Internet Explorer 8 ou supérieur, vous devez procéder comme suit:
- Lancez "Outils de développement, en cliquant sur le bouton F12
- Sur la liste des onglets, cliquez sur l'onglet "Script"
- Cliquez sur le bouton "Console" dans le côté droit
Pour plus d'informations, vous pouvez visiter cette URL: https://developer.chrome.com/devtools/docs/console-api
Quelques améliorations sur la fonction de nickf pour ceux qui ne connaissent pas le type de variable entrant:
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;
}
}
J'ai amélioré la réponse de nickf, donc il parcourt les objets de manière récursive
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;
}
Si vous recherchez la fonction PHP convertie en JS, voici le petit site: http://phpjs.org . Vous pouvez y trouver la plupart de la fonction PHP de manière fiable écrit en JS. pour var_dump, essayez: http://phpjs.org/functions/var_dump/ (assurez-vous de vérifier le commentaire en haut, cela dépend de "echo", qui peut également être téléchargé à partir du même site)
J'ai utilisé la première réponse, mais je sentais qu'il manquait une récursion.
Le résultat était ceci:
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);
}
Basé sur les fonctions précédentes trouvées dans cet article . Ajout du mode récursif et de l'indentation.
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;
}
Exemple
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>";
Résultat
b: 1 (number)
c:
d: 3 (number)
e: 2 (number)
c:
d: 3 (number)
e: 2 (number)
Vous pouvez simplement utiliser le package NPM var_dump
npm install var_dump --save-dev
Usage:
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)
Cela va imprimer:
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"
}
}
}
}
}
Lien: https://www.npmjs.com/package/@smartankur4u/vardump
Remercie moi plus tard!
Ce qui suit est mon préféré var_dump/print_r equivalent in Javascript to 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;
}
En retard dans le jeu, mais voici une fonction très pratique, extrêmement simple à utiliser, qui vous permet de transmettre autant d’arguments que vous le souhaitez, de tout type, et affiche le contenu de l’objet dans la fenêtre de la console du navigateur comme si vous appeliez console. se connecter depuis JavaScript - mais depuis PHP
Notez que vous pouvez également utiliser des balises en passant "TAG-YourTag". Elles seront appliquées jusqu'à la lecture d'une autre balise, par exemple "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>";
}
}
}
}
NOTE: func_num_args () et func_num_args () sont des fonctions php permettant de lire un nombre dynamique d'arguments en entrée, et permettent à cette fonction de recevoir un nombre infini de demandes console.log à partir d'un appel de fonction