Chrome JavaScript-Entwicklerkonsole: Ist es möglich, console.log () ohne Zeilenumbruch aufzurufen?

Ich möchte console.log () verwenden, um Nachrichten zu protokollieren, ohne nach jedem Aufruf von console.log () eine neue Zeile anzuhängen. Ist das möglich?

Nein, es ist nicht möglich. Sie müssen eine Zeichenfolge beibehalten und verketten, wenn Sie alles in einer Zeile haben möchten, oder Ihre Ausgabe an einer anderen Stelle platzieren (z. B. in einem anderen Fenster).

In NodeJS können Sie process.stdout.write verwenden und bei Bedarf '\ n' hinzufügen.

console.log(msg)ist äquivalent zu process.stdout.write(msg + '\n').

Sie können so viele Dinge argumentseingeben, wie Sie möchten:

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

Sie erhalten die gesamte Ausgabe in einer Zeile mit den Objektreferenzen inline und können dann die Inspektoren von dort aus ablegen.

Ja, es ist möglich (siehe Demo unten) - indem Sie Ihre eigene virtuelle Konsole über der nativen Browserkonsole implementieren und dann mit der realen Konsole synchronisieren.

Das ist viel einfacher als es sich anhört:

1. einen Anzeigepuffer beibehalten (z. B. ein Array von Zeichenfolgen, die jeweils eine Zeile darstellen)
2. Rufen Sie console.clear()vor dem Schreiben an, um frühere Inhalte zu löschen
3. Rufen Sie console.log()(oder warnen, Fehler usw.) auf, um die Konsole mit dem Inhalt Ihres Anzeigepuffers zu füllen

Eigentlich mache ich das schon seit einiger Zeit. Eine kurze, rudimentäre Umsetzung der Idee wäre in etwa so, könnte aber dennoch den Konsoleninhalt animieren:

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

Es hat sicherlich seine Nachteile beim Mischen mit direkter Konsoleninteraktion und kann definitiv hässlich aussehen - aber es hat sicherlich seine gültigen Verwendungen, die Sie ohne es nicht erreichen könnten.

Die kurze Antwort lautet nein.

Aber

Wenn Ihr Anwendungsfall den Versuch beinhaltet, sich ständig ändernde Daten zu protokollieren und dabei das Aufblähen der Konsole zu vermeiden, besteht eine Möglichkeit, dies (in bestimmten Browsern) zu erreichen, darin, sie console.clear()vor jeder Ausgabe zu verwenden.

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

Beachten Sie, dass dies wahrscheinlich alle anderen Protokollierungsfunktionen Ihrer Anwendung beeinträchtigen würde.

Haftungsausschluss: Ich würde dies als Hack klassifizieren.

Wenn Sie nur das Drucken in vielen Zeilen beenden möchten, können Sie die Werte gruppieren, wenn Sie nicht möchten, dass sie Ihre gesamte Konsole füllen

PS: - Siehe Browser-Konsole für die Ausgabe

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


console.groupCollapsed('index')

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

console.groupEnd()

console.group

console.groupCollapsed

Etwas über die @ shennan-Idee:

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

Sammeln Sie Ihre Ausgabe in einem Array und verwenden Sie dann die Verknüpfungsfunktion mit einem bevorzugten Trennzeichen

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

echo("apple",3)

Überprüfen Sie auch Array.prototype.join () für Details zum Modus

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

Sie können einen Spread-Operator verwenden, um die Ausgabe in einer einzelnen Zeile anzuzeigen. Die neue Funktion von Javascript ES6. siehe unten Beispiel

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

Dadurch werden 1 bis 10 Tabellen in einer Zeile gedruckt.

Wenn Sie beispielsweise Konsolenprotokoll-Array-Elemente ohne Zeilenumbruch möchten, können Sie dies tun

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 

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