අපි alertවිචල්‍යයක් වන විට මෙන් ජාවාස්ක්‍රිප්ට් වස්තුවක අන්තර්ගතය නූල් ආකෘතියකින් පෙන්වන්නේ කෙසේද?

වස්තුවක් ප්‍රදර්ශනය කිරීමට අවශ්‍ය එකම ආකෘතිගත ක්‍රමය.

නිදොස් කිරීමේ අරමුණු සඳහා ඔබට වස්තුව මුද්‍රණය කිරීමට අවශ්‍ය නම්, කේතය භාවිතා කරන්න:

var obj = {prop1: 'prop1Value', prop2: 'prop2Value', child: {childProp1: 'childProp1Value'}}
console.log(obj)

දර්ශණය වනු ඇත:

සටහන: ඔබ කළ යුත්තේ වස්තුව පමණි . උදාහරණයක් ලෙස, මෙය ක්‍රියා නොකරනු ඇත:

console.log('My object : ' + obj)

සටහන ' : ඔබට logක්‍රමයේදී කොමාව භාවිතා කළ හැකිය , එවිට ප්‍රතිදානයේ පළමු පේළිය නූල් වන අතර ඉන් පසුව වස්තුව විදැහුම් වේ:

console.log('My object: ', obj);

ස්වදේශීය JSON.stringifyක්‍රමය භාවිතා කරන්න . කැදැලි සහිත වස්තූන් සමඟ ක්‍රියා කරන අතර සියලුම ප්‍රධාන බ්‍රව්සර් මෙම ක්‍රමයට සහාය වේ.

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

මොසිල්ලා ඒපීඅයි යොමු සහ වෙනත් උදාහරණ වෙත සබැඳිය .

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

ඔබට මෙම ජාවාස්ක්‍රිප්ට් දෝෂය හමු වුවහොත් අභිරුචි JSON.stringify ආදේශකයක් භාවිතා කරන්න

"Uncaught TypeError: Converting circular structure to JSON"

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

console.dir(object):

නිශ්චිත ජාවාස්ක්‍රිප්ට් වස්තුවක ගුණාංගවල අන්තර්ක්‍රියාකාරී ලැයිස්තුවක් පෙන්වයි. ළමා වස්තූන්ගේ අන්තර්ගතය පරීක්ෂා කිරීම සඳහා අනාවරණය කිරීමේ ත්‍රිකෝණ භාවිතා කිරීමට මෙම ලැයිස්තුගත කිරීම ඔබට ඉඩ සලසයි.

console.dir()විශේෂාංගය සම්මත නොවන බව සලකන්න . MDN වෙබ් ලියකියවිලි බලන්න

මේක උත්සාහ කරන්න :

console.log(JSON.stringify(obj))

මෙය වස්තුවෙහි දැඩි අනුවාදය මුද්‍රණය කරනු ඇත. එබැවින් [object]ප්‍රතිදානයක් ලෙස වෙනුවට ඔබට වස්තුවේ අන්තර්ගතය ලැබෙනු ඇත.

හොඳයි, ෆයර්ෆොක්ස් (සවිස්තරාත්මක තොරතුරු සඳහා o බොජැන්ගල්ස් වලට ස්තූතියි) Object.toSource()JSON සහ function(){}.

බොහෝ නිදොස් කිරීමේ අරමුණු සඳහා එය ප්‍රමාණවත් යැයි මම සිතමි.

ඔබේ වස්තුව මුද්‍රණය කිරීම සඳහා ඔබට ඇඟවීම් භාවිතා කිරීමට අවශ්‍ය නම්, ඔබට මෙය කළ හැකිය:

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

එය එක් එක් දේපල සහ එහි අනුරූප වටිනාකම නූල් ආකෘතියෙන් මුද්‍රණය කළ යුතුය.

දත්ත වගු ආකෘතියෙන් බැලීමට ඔබ කැමති නම් ඔබට භාවිතා කළ හැකිය

console.table(obj);

ඔබ මේස තීරුව මත ක්ලික් කළහොත් වගුව වර්ග කළ හැකිය.

පෙන්විය යුතු තීරු ද ඔබට තෝරා ගත හැකිය:

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

ඔබට console.table පිළිබඳ වැඩි විස්තර මෙතැනින් සොයාගත හැකිය

NodeJS හි ඔබට භාවිතයෙන් වස්තුවක් මුද්‍රණය කළ හැකිය util.inspect(obj). ගැඹුර සඳහන් කිරීමට වග බලා ගන්න හෝ ඔබට ඇත්තේ වස්තුවේ නොගැඹුරු මුද්‍රණයක් පමණි.

කාර්යය:

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

භාවිතය:

var myObject = {
    name: 'Wilson Page',
    contact: {
        email: 'wilson@hotmail.com',
        tel: '123456789'
    }  
}

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

උදාහරණයක්:

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

සරලව භාවිතා කරන්න

JSON.stringify(obj)

උදාහරණයක්

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

හෝ

alert(args_string);

එසේම, javascript ශ්‍රිතවල සටහන වස්තු ලෙස සැලකේ.

අමතර සටහනක් ලෙස:

ඇත්ත වශයෙන්ම ඔබට මේ වගේ නව දේපළ පැවරිය හැකි අතර එය console.log වෙත පිවිසිය හැකිය

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

මෙය භාවිතා කරන්න:

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

එය කලින් පැවසූ පරිදි හොඳම හා සරලවම මා සොයාගත් මාර්ගය විය

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

ප්‍රසාද දීමනාවක් ලෙස වර්ණ සමඟ Node.js සමඟ සම්පූර්ණ වස්තුව මුද්‍රණය කිරීම :

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

වර්ණ ඇත්ත වශයෙන්ම අත්‍යවශ්‍ය නොවේ, 'ගැඹුර: ශූන්‍යය' සම්පූර්ණ වස්තුව මුද්‍රණය කරයි.

විකල්ප බ්‍රව්සර් තුළ සහය දක්වන බවක් නොපෙනේ.

යොමුව:

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

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

සැ.යු: මෙම උදාහරණ වලදී, ඔබ පරීක්ෂා කිරීමට අවශ්‍ය වස්තුව ඔබේ ඕබ් විසින් අර්ථ දක්වයි.

වස්තුවක් ප්‍රදර්ශනය කිරීමේ මගේ අවම ප්‍රියතම සහ වඩාත්ම උපයෝගී කරගත් ක්‍රමයෙන් පළමුව:

වස්තුවක අන්තර්ගතය පෙන්වීමේ defacto ක්‍රමය මෙයයි

console.log(yourObj)

වැනි දෙයක් නිපදවනු ඇත:

මම හිතන්නේ හොඳම විසඳුම වස්තු යතුරු හරහා බැලීම, පසුව වස්තු වටිනාකම් හරහා ඔබට සැබවින්ම වස්තුව රඳවාගෙන ඇති දේ දැකීමට අවශ්‍ය නම් ...

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

එය මෙවැනි දෙයක් ප්‍රතිදානය කරයි: (ඉහත පින්තූරයේ: වස්තුව තුළ ගබඩා කර ඇති යතුරු / අගයන්)

ඔබ ECMAScript 2016 හෝ නව භාවිතා කරන්නේ නම් මෙම නව විකල්පය ද ඇත:

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

මෙය පිළිවෙලින් ප්‍රතිදානය නිපදවනු ඇත: පෙර පිළිතුරක සඳහන් විසඳුම: console.log(yourObj)ඕනෑවට වඩා පරාමිතීන් පෙන්වන අතර ඔබට අවශ්‍ය දත්ත ප්‍රදර්ශනය කිරීමට වඩාත්ම පරිශීලක හිතකාමී ක්‍රමය නොවේ . ලොග් යතුරු සහ පසුව අගයන් වෙන වෙනම නිර්දේශ කරන්නේ එබැවිනි.

ඊළඟට:

console.table(yourObj)

කලින් අදහස් දැක්වීමක කවුරුහරි මෙය යෝජනා කළ නමුත් එය කිසි විටෙකත් මට ප්‍රයෝජනවත් නොවීය. එය වෙනත් බ්‍රව්සරයක හෝ වෙනත් දෙයක වැඩ කරන්නේ නම්, කුඩෝස්! මම තවමත් කේතය මෙහි යොමු කිරීම සඳහා තබා ඇත! මේ වගේ දෙයක් කොන්සෝලය වෙත ප්‍රතිදානය කරයි:

ඔබ එහි සම්පූර්ණ දිග වස්තුව මුද්‍රණය කිරීමට කැමති නම්, භාවිතා කළ හැකිය

console.log (අවශ්‍යයි ('util'). පරීක්ෂා කරන්න (obj, {showHidden: false, ගැඹුර: null})

ඔබට එම වස්තුව නූල් බවට පරිවර්තනය කිරීමෙන් මුද්‍රණය කිරීමට අවශ්‍ය නම්

console.log (JSON.stringify (obj));

(මෙය GitHub හි මගේ පුස්තකාලයට එක් කර ඇත )

මෙහි රෝදය ප්‍රතිනිර්මාණය කිරීම! මෙම විසඳුම් කිසිවක් මගේ තත්වය සඳහා සාර්ථක වූයේ නැත. ඒ නිසා, මම ඉක්මනින් විල්සන්ගේ පිළිතුරට උපදෙස් දුන්නා. මෙය තිරයට මුද්‍රණය කිරීම සඳහා නොවේ (කොන්සෝලය, හෝ පෙළ ක්ෂේත්‍රය හෝ වෙනත් ඕනෑම දෙයක් හරහා). එම අවස්ථාවන්හිදී එය හොඳින් ක්‍රියාත්මක වන අතර OP ඉල්ලා ඇති ආකාරයටම හොඳින් ක්‍රියාත්මක වේ alert. alertOP ඉල්ලූ පරිදි මෙහි බොහෝ පිළිතුරු ආමන්ත්‍රණය නොකරයි . කෙසේ වෙතත්, එය දත්ත ප්‍රවාහනය සඳහා සංයුති කර ඇත. මෙම අනුවාදය සමාන ප්‍රති result ලයක් ලබා දෙන බව පෙනේ toSource(). මම එරෙහිව පරීක්ෂාවට ලක් කර නැත JSON.stringify, නමුත් මම සිතන්නේ මෙය එකම දෙයකි. මෙම අනුවාදය ඔබට ඕනෑම පරිසරයක භාවිතා කළ හැකි වන පරිදි පොලි ෆිල් එකක් වැනි ය. මෙම ශ්‍රිතයේ ප්‍රති result ලය වලංගු ජාවාස්ක්‍රිප්ට් වස්තු ප්‍රකාශයකි.

මේ වගේ දෙයක් දැනටමත් SO හි කොතැනක හෝ තිබේදැයි මට සැක නැත, නමුත් අතීත පිළිතුරු සෙවීමට ටික වේලාවක් ගත කරනවාට වඩා එය සෑදීම කෙටි විය. මම මේ ගැන සෙවීම ආරම්භ කරන විට මෙම ප්‍රශ්නය ගූගල් හි මගේ ඉහළම පහර වූ බැවින්; මම හිතුවා ඒක මෙතනට දාන්න අනිත් අයට උදව් වෙයි කියලා.

කෙසේ වෙතත්, මෙම ශ්‍රිතයේ ප්‍රති result ලය වනුයේ ඔබේ වස්තුව වස්තූන් හා අරා කාවැදී තිබුණත්, එම වස්තූන් හෝ අරා තව දුරටත් කාවැද්දූ වස්තූන් හා අරා තිබුණත් ඔබේ වස්තුවෙහි තන්තු නිරූපණයකි. (ඔබ බොන්න කැමති බව මට ඇසුණාද? ඉතින්, මම ඔබේ මෝටර් රථය සිසිලන යන්ත්‍රයකින් තල්ලු කළෙමි. ඉන්පසු මම ඔබේ සිසිලකය සිසිලනකාරකයක් සමඟ ගැසුවෙමි. එබැවින් සිසිල්ව සිටියදී ඔබේ සිසිලන පානය කළ හැකිය.)

අරා []වෙනුවට ගබඩා කර ඇති {}අතර එමඟින් යතුරු / අගය යුගල, අගයන් පමණක් නොමැත. සාමාන්‍ය අරා වගේ. එමනිසා, ඒවා අරා මෙන් නිර්මාණය වේ.

එසේම, සියලුම නූල් (යතුරු නම් ඇතුළුව) උපුටා දක්වා ඇත, එම නූල් වලට විශේෂ අක්ෂර (අවකාශයක් හෝ කප්පාදුවක් වැනි) නොමැති නම් මෙය අවශ්‍ය නොවේ. එහෙත්, සමහර විට උපුටා දැක්වීම් ඉවත් කිරීම සඳහා මෙය හඳුනා ගැනීමට මට දැනුනේ නැත.

මෙහි evalප්‍රති string ලයක් ලෙස භාවිතා කළ හැකි නූල භාවිතා කළ හැකිය. මේ අනුව, පෙළෙන් ඔබේ වස්තුව නැවත නිර්මාණය කිරීම.

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)+"]";
}

මම ඒ සියල්ල අවුල් කර ඇත්දැයි මට දන්වන්න, මගේ පරීක්ෂණයේදී හොඳින් ක්‍රියා කරයි. එසේම, වර්ගය හඳුනා ගැනීමට මට සිතිය හැකි එකම ක්‍රමය arrayතිබුනේ දැයි පරීක්ෂා කිරීමයි length. ජාවාස්ක්‍රිප්ට් සැබවින්ම අරා වස්තු ලෙස ගබඩා කර ඇති නිසා, මට ඇත්ත වශයෙන්ම වර්ගය පරීක්ෂා කළ arrayනොහැක (එවැනි වර්ගයක් නොමැත!). වෙන කවුරුහරි වඩා හොඳ ක්‍රමයක් දන්නේ නම්, මම එය ඇසීමට කැමතියි. මන්ද, ඔබේ වස්තුවට නමක් ඇති දේපලක් තිබේ නම් lengthමෙම ශ්‍රිතය වැරදීමකින් එය අරාව ලෙස සලකනු ඇත.

සංස්කරණය කරන්න: ශුන්‍ය වටිනාකමින් යුත් වස්තු සඳහා චෙක්පතක් එක් කරන ලදි. ස්තූතියි බ්‍රොක් ඇඩම්ස්

සංස්කරණය කරන්න: අසීමිත පුනරාවර්තන වස්තු මුද්‍රණය කිරීමට හැකි ස්ථාවර කාර්යය පහත දැක්වේ. මෙය toSourceඑෆ්එෆ් වෙතින් සමාන ලෙස මුද්‍රණය නොකෙරේ, මන්දයත් toSourceඑක් වරක් අනන්ත පුනරාවර්තනය මුද්‍රණය වන අතර එහිදී මෙම ශ්‍රිතය එය වහාම විනාශ කරයි. මෙම ශ්‍රිතය ඉහත ක්‍රියාකාරිත්වයට වඩා මන්දගාමීව ක්‍රියාත්මක වේ, එබැවින් ඉහත ශ්‍රිතය සංස්කරණය කරනවා වෙනුවට මම එය මෙහි එක් කරමි.

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)+"]";
}

පරීක්ෂණය:

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

ප්‍රති ult ලය:

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

සටහන: මුද්‍රණය කිරීමට උත්සාහ කිරීම document.bodyභයානක උදාහරණයකි. එකක් සඳහා, FF භාවිතා කරන විට හිස් වස්තු නූලක් මුද්‍රණය කරයි toSource. ඉහත ශ්‍රිතය භාවිතා කරන විට, එෆ්එෆ් බිඳ වැටේ SecurityError: The operation is insecure.. තවද ක්‍රෝම් බිඳ වැටෙනු ඇත Uncaught RangeError: Maximum call stack size exceeded. පැහැදිලිවම, document.bodyනූල් බවට පරිවර්තනය කිරීමට අදහස් නොකෙරුණි. මන්ද එය එක්කෝ විශාල හෝ ආරක්ෂක ප්‍රතිපත්තියට එරෙහිව ඇතැම් දේපලවලට ප්‍රවේශ වීමට නොහැකි බැවිනි. මම මෙහි යමක් අවුල් කළොත් මිස කියන්න!

එය කිරීමට ක්‍රමයක් මෙන්න:

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

පිටු වස්තුවේ පිළිතුර සපයන වස්තුව නැවත නැවත මුද්‍රණය කිරීමට මට ක්‍රමයක් අවශ්‍ය විය (ස්තූතියි!). කිසියම් මට්ටමකට මුද්‍රණය කිරීමට ක්‍රමයක් ඇතුළත් කිරීමටත්, පරතරය එක් කිරීමටත් මම එය ටිකක් යාවත්කාලීන කළෙමි, එමඟින් එය අප සිටින වර්තමාන මට්ටම මත පදනම්ව නිසි ලෙස මුද්‍රණය කර ඇති අතර එය වඩාත් කියවිය හැකි ය.

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

භාවිතය:

var pagewilsObject = {
    name: 'Wilson Page',
    contact: {
        email: 'wilson@hotmail.com',
        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) ); 

මම නිතරම භාවිතා කරමි console.log("object will be: ", obj, obj1). මේ ආකාරයෙන් මට JSON සමඟ දැඩි ලෙස කටයුතු කිරීම අවශ්‍ය නොවේ. වස්තුවේ සියලුම ගුණාංග මනාව පුළුල් වේ.

කොන්සෝලය තුළ වස්තු ප්‍රදර්ශනය කිරීමේ තවත් ක්‍රමයක් වන්නේ JSON.stringify. පහත උදාහරණය බලන්න:

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

ජාවාස්ක්‍රිප්ට් ශ්‍රිතය

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

මුද්‍රණ වස්තුව

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

Javascript හි print_r හරහා

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

objectඔබේ වස්තුව කොහෙද ?

හෝ ඔබට මෙය ක්‍රෝම් ඩිව් මෙවලම්, "කොන්සෝලය" පටිත්තෙහි භාවිතා කළ හැකිය:

console.log(object);

වස්තුව උපකල්පනය කරන්න obj = {0:'John', 1:'Foo', 2:'Bar'}

වස්තුවේ අන්තර්ගතය මුද්‍රණය කරන්න

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

කොන්සෝල ප්‍රතිදානය (Chrome DevTools):

John 0
Foo 1
Bar 2

උපකාරවත් වන බලාපොරොත්තුව!

ජාවාස්ක්‍රිප්ට් වස්තුවක අන්තර්ගතය නූල් ආකෘතියෙන් ප්‍රදර්ශනය කිරීම සඳහා ඔබට ES6 අච්චු වචනාර්ථමය සංකල්පය භාවිතා කළ හැකිය.

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

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

console.tableපැහැදිලි වස්තු ආකෘතියක් ලබා ගැනීම සඳහා මම භාවිතා කිරීමට කැමැත්තෙමි , එබැවින් ඔබට මෙම වස්තුව ඇතැයි සිතන්න:

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

පහත දැක්වෙන පරිදි පිළිවෙලට හා කියවිය හැකි වගුවක් ඔබට පෙනෙනු ඇත:

කුඩා උපකාරක කාර්යයක් මම සෑම විටම මගේ ව්‍යාපෘති වල කොන්සෝලය හරහා සරල, ඉක්මන් නිදොස්කරණය සඳහා භාවිතා කරමි. 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) + ')');
}

භාවිතය

dd(123.55); ප්‍රතිදානයන්:

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

මම පේජ්විල්ගේ මුද්‍රණ ක්‍රමය භාවිතා කළ අතර එය ඉතා හොඳින් ක්‍රියාත්මක විය.

(බෑවුම් සහිත) ඉන්ඩෙන්ට්ස් සහ විශේෂිත මුක්කු / ඕබ් පරිසීමක සහිත මගේ තරමක් දිගු කළ අනුවාදය මෙන්න:

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

පේජ්විල්ස් කේතයේ තවත් වෙනස් කිරීමක් ... ඔහු නූල් හැර වෙනත් කිසිවක් මුද්‍රණය නොකරන අතර අංකය සහ බූලියන් ක්ෂේත්‍ර හිස්ව තබයි. මෙගාබොස් විසින් නිර්මාණය කරන ලද පරිදි ශ්‍රිතය තුළම දෙවන වර්ගයේ යතුරු ලියනය සවි කළෙමි.

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

මෙන්න කාර්යය.

function printObj(obj) {
console.log((function traverse(tab, obj) {
    let str = "";
    if(typeof obj !== 'object') {
        return obj + ',';
    }
    if(Array.isArray(obj)) {            
        return '[' + obj.map(o=>JSON.stringify(o)).join(',') + ']' + ',';
    }
    str = str + '{\n';
    for(var p in obj) {
        str = str + tab + ' ' + p + ' : ' + traverse(tab+' ', obj[p]) +'\n';
    }
    str = str.slice(0,-2) + str.slice(-1);                
    str = str + tab + '},';
    return str;
}('',obj).slice(0,-1)))};

කියවීමේ හැකියාව සහිත ටැබ් ඉන්ඩෙන්ට් භාවිතයෙන් එය වස්තුව පෙන්විය හැකිය.