Chrome जावास्क्रिप्ट डेवलपर कंसोल: क्या यह एक नई लाइन के बिना कंसोल.लॉग () को कॉल करना संभव है?

Question

मैं कंसोल.लॉग () के लिए प्रत्येक कॉल के बाद एक नई लाइन को जोड़ने के बिना कंसोल लॉग () संदेशों का उपयोग करना चाहता हूं । क्या यह संभव है?

Comments

क्या एक उत्तर सही था?

— newenglander

मुझे लगता है कि @ मिनिटेक का उत्तर सही है: यह संभव नहीं है। अन्य उत्तर दिलचस्प प्रदान करते हैं, अगर कुछ हद तक ओर्थोगोनल गहराई से सांत्वना की हमारी समझ है। ()।

— डेव लैंड

@DaveLand मेरा मानना है कि यह है पूरी तरह से संभव अपने स्वयं के प्रदर्शन बफर को बनाए रखने, और का एक संयोजन द्वारा वास्तविक कंसोल के लिए कि प्रदर्शन बफर समन्वयित करके console.clear()जैसे और, console.log()।

— जॉन वीज़

@JohnWeisz: धन्यवाद, लेकिन हर "इनलाइन" अपडेट के लिए पूरे कंसोल को पोंछना लगभग 99% अनुप्रयोगों का समाधान नहीं है। फिर भी, एक updoot है।

— डेव लैंड

@DaveLand हाँ, यह एक हैक की तरह है - और अब जब मैंने चारों ओर देखा, मुझे एहसास हुआ कि यह पहले प्रस्तावित किया गया है। किसी भी तरह से, यह कई बार उपयोगी हो सकता है।

— जॉन वीज

Answer 1

नहीं, यह संभव नहीं है। यदि आप यह सब एक पंक्ति में चाहते हैं, तो आपको एक स्ट्रिंग और समवर्ती रखना होगा, या अपना आउटपुट कहीं और डालेंगे (जैसे, दूसरी विंडो)।

Comments

वास्तव में, यह संभव है, लेकिन शायद हर किसी के दिमाग में इसका इस्तेमाल न हो। मेरे मामले में, मैं केवल कमांड लाइन टर्मिनल से इनपुट प्राप्त करने के लिए एक प्रश्न प्रिंट करने की कोशिश कर रहा था। इस प्रश्न का उत्तर उत्तर के लिए देखें: stackoverflow.com/questions/26683734/…

— deltaray

@deltaray रीडलाइन की questionनहीं है console.log। सवाल ब्राउज़र कंसोल के बारे में भी है, न कि Node.js.

— Ry-

@ मिनिटेक आप एक लाइन में प्रिंट करने के लिए फैल ऑपरेटर का उपयोग कर सकते हैं। उदाहरण में देखें jsfiddle.net/imranqau5373/7m65at9L/2

— imran khan

@imrankhan: यह सवाल नहीं था। प्रसार संचालक यहाँ कुछ भी नया नहीं जोड़ सकता है apply।

— Ry-

Answer 2

NodeJS में आप process.stdout.write का उपयोग कर सकते हैं और यदि आप चाहें तो '\ n' जोड़ सकते हैं।

console.log(msg)के बराबर है process.stdout.write(msg + '\n')।

Comments

NodeJS क्रोम नहीं है । यह उत्तर इस सवाल के लिए अप्रासंगिक है 'क्या आप बिना किसी नई जानकारी के सांत्वना दे सकते हैं?' ।

— एलेक्स

Answer 3

आप जितनी चाहें उतनी चीजें रख सकते argumentsहैं:

console.log('hi','these','words','will','be','separated','by','spaces',window,document)

आपको वह सभी आउटपुट एक लाइन पर ऑब्जेक्ट रेफरेंस इनलाइन के साथ मिलेंगे और फिर आप अपने इंस्पेक्टरों को वहां से हटा सकते हैं।

Comments

यह प्रश्न का उत्तर कैसे देता है?

— जॉन एलेन

मुझे लगता है कि यह उत्तर उपयोगी है।

यह उपयोगी है। भले ही यह सवाल का जवाब नहीं देता है, लेकिन यह एक समाधान प्रदान करता है कि अधिकांश लोग इस सवाल का पता लगाने के लिए क्या देख रहे हैं।

— सीन लिंच

नई लाइन के बिना कोई भी प्रिंट करना चाहेगा, इसका कारण यह है कि निम्न आउटपुट ज्ञात नहीं है। या उदाहरण के लिए डॉट्स का उपयोग करके "लोडर बार" की कल्पना करें।

— कार्ल एडलर

कई तर्कों का उपयोग करने से कंसोल.लॉग स्टाइल टूट जाता है क्योंकि आप पहले तर्क के भीतर ही स्टाइल कर सकते हैं।

— क्वर्टी

Answer 4

हां, यह संभव है (नीचे दिए गए डेमो को देखें) - देशी ब्राउज़र कंसोल के शीर्ष पर अपना खुद का वर्चुअल कंसोल लागू करके, फिर इसे वास्तविक पर सिंक करके।

यह जितना लगता है उससे कहीं अधिक आसान है:

1. प्रदर्शन बफर बनाए रखें (उदाहरण के लिए एक पंक्ति का प्रतिनिधित्व करने वाले तारों का एक सरणी)
2. console.clear()किसी भी पिछली सामग्री को मिटाने के लिए लिखने से पहले कॉल करें
3. console.log()अपने प्रदर्शन बफर से सामग्री के साथ कंसोल को भरने के लिए कॉल (या चेतावनी, त्रुटि, आदि)

दरअसल, मैं पिछले कुछ समय से ऐसा कर रहा हूं। विचार की एक संक्षिप्त, अल्पविकसित कार्यान्वयन निम्नलिखित पंक्तियों के साथ कुछ होगा, लेकिन अभी भी कंसोल सामग्री को एनिमेट करने में सक्षम है :

// =================================================
// Rudimentary implementation of a virtual console.
// =================================================

var virtualConsole = {
    lines: [],
    currentLine: 0,
    log: function (msg, appendToCurrentLine) {
        if (!appendToCurrentLine) virtualConsole.currentLine++;
      
        if (appendToCurrentLine && virtualConsole.lines[virtualConsole.currentLine]) {
            virtualConsole.lines[virtualConsole.currentLine] += msg;
        } else {
            virtualConsole.lines[virtualConsole.currentLine] = msg;
        }
        
        console.clear();
        
        virtualConsole.lines.forEach(function (line) {
            console.log(line);
        });
    },
    clear: function () {
        console.clear();
        virtualConsole.currentLine = 0;
    }
}

// =================================================
// Little demo to demonstrate how it looks.
// =================================================

// Write an initial console entry.
virtualConsole.log("Loading");

// Append to last line a few times.
var loadIndicatorInterval = setInterval(function () {
    virtualConsole.log(".", true); // <- Append.
}, 500);

// Write a new line.
setTimeout(function () {
    clearInterval(loadIndicatorInterval);
    virtualConsole.log("Finished."); // <- New line.
}, 8000);

प्रत्यक्ष कंसोल इंटरेक्शन के साथ मिश्रण करने पर यह निश्चित रूप से अपनी कमियां है, और निश्चित रूप से बदसूरत दिख सकता है - लेकिन इसमें निश्चित रूप से इसके वैध उपयोग हैं, जो आप इसके बिना हासिल नहीं कर सकते।

Comments

यह यहां सबसे अच्छा जवाब है। आप यह भी कह सकते हैं कि अधिकतम लाइनें जो लॉग स्टैक को पर्याप्त रूप से छोटा रखती हैं, ताकि आप डेटा के विशाल सेट को लॉग इन न करें।

— मैट वे

Answer 5

संक्षिप्त जवाब नहीं है।

परंतु

यदि आपके उपयोग-मामले में कंसोल-ब्लोट से बचने के दौरान लगातार बदलते डेटा को लॉग इन करने का प्रयास शामिल है, तो इसे प्राप्त करने का एक तरीका (कुछ ब्राउज़रों में) console.clear()प्रत्येक आउटपुट से पहले उपयोग करना होगा ।

function writeSingleLine (msg) {

  console.clear();
  console.log(msg);

}

writeSingleLine('this');
setTimeout( function () { writeSingleLine('is'); }, 1000);
setTimeout( function () { writeSingleLine('a'); }, 2000);
setTimeout( function () { writeSingleLine('hack'); }, 3000);

ध्यान दें कि यह संभवतः किसी अन्य लॉगिंग कार्यक्षमता को तोड़ देगा जो आपके एप्लिकेशन के भीतर हो रही थी।

अस्वीकरण: मैं इसे हैक के रूप में वर्गीकृत करूंगा।

Comments

बहुत हैक, लेकिन चतुर। यदि आपने ट्रैक किया है कि पहले से ही कंसोल में क्या लॉग किया गया है (कुछ प्रकार के वर्चुअल बफर को बनाए रखने के द्वारा), तो आप बफर को फिर से बना सकते हैं और हर बार जब आप साफ करते हैं तो एक नया स्ट्रिंग जोड़ सकते हैं।

— danShumway

Answer 6

यदि आपका एकमात्र उद्देश्य कई लाइनों पर मुद्रण को रोकना है, तो एक तरीका यह है कि यदि आप उन्हें अपना पूरा कंसोल नहीं भरना चाहते हैं तो मूल्यों को समूहित करें

PS: - आप आउटपुट के लिए ब्राउज़र कंसोल देखें

let arr = new Array(10).fill(0)


console.groupCollapsed('index')

arr.forEach((val,index) => {
  console.log(index)
})

console.groupEnd()

console.group

console.groupCollapsed

Answer 7

@Shennan विचार के बारे में कुछ:

function init(poolSize) {
      var pool = [];
      console._log = console.log;
      console.log = function log() {
        pool.push(arguments);
        while (pool.length > poolSize) pool.shift();
    
        draw();
      }
      console.toLast = function toLast() {
        while (pool.length > poolSize) pool.shift();
        var last = pool.pop() || [];
        for (var a = 0; a < arguments.length; a++) {
            last[last.length++] = arguments[a];
        }
        pool.push(last);
    
        draw();
      }
      function draw() {
        console.clear();
        for(var i = 0; i < pool.length; i++)
          console._log.apply(console, pool[i]);
      }
    }
    
    function restore() {
      console.log = console._log;
      delete console._log;
      delete console.toLast;
    }
    
    init(3);
    console.log(1);
    console.log(2);
    console.log(3);
    console.log(4);    // 1 will disappeared here
    console.toLast(5); // 5 will go to row with 4
    restore();

Answer 8

अपने आउटपुट को एक सरणी में इकट्ठा करें और फिर पसंदीदा विभाजक के साथ जुड़ने वाले फ़ंक्शन का उपयोग करें

function echo(name, num){
    var ar= [];
    for(var i =0;i<num;i++){
        ar.push(name);
    }
    console.log(ar.join(', '));
}

echo("apple",3)

मोड विवरण के लिए Array.prototyp.join () भी देखें

var elements = ['Fire', 'Wind', 'Rain'];

console.log(elements.join());
// expected output: Fire,Wind,Rain

console.log(elements.join(''));
// expected output: FireWindRain

console.log(elements.join('-'));
// expected output: Fire-Wind-Rain

Answer 9

आप एकल लाइन में आउटपुट प्रदर्शित करने के लिए एक प्रसार ऑपरेटर का उपयोग कर सकते हैं। जावास्क्रिप्ट ES6 की नई विशेषता। नीचे उदाहरण देखें

   for(let i = 1; i<=10; i++){
        let arrData = [];
        for(let j = 1; j<= 10; j++){
            arrData.push(j+"X"+i+"="+(j*i));
        }
        console.log(...arrData);
    }

जो सिंगल लाइन में 1 से 10 टेबल प्रिंट करेगा।

Answer 10

यदि आप उदाहरण के लिए एक नई लाइन के बिना कंसोल लॉग ऐरे तत्वों को चाहते हैं, तो आप ऐसा कर सकते हैं

const arr = [1,2,3,4,5];

Array.prototype.log = (sep='') => {
    let res = '';
    for(let j=0; j<this.lengthl j++){
        res += this[j];
        res += sep;
    }
    console.log(res);
}

// console loging

arr.log(sep=' '); // result is: 1 2 3 4 5 

Answer 11

// Source code for printing 2d array
window.onload = function () {
    var A = [[1, 2], [3, 4]];
    Print(A);
}

function Print(A) {
    var rows = A.length;
    var cols = A[0].length;
    var line = "";
    for (var r = 0; r < rows; r++) {
        line = "";
        for (var c = 0; c < cols; c++) {
            line += A[r][c] + " ";
        }
        console.log(line);
    }
}

Comments

A.forEach(row => console.log(row.join(' ')))

— vp_arth