Konsola programisty Chrome JavaScript: czy można wywołać console.log () bez znaku nowej linii?

Chciałbym używać console.log () do rejestrowania komunikatów bez dodawania nowego wiersza po każdym wywołaniu console.log (). czy to możliwe?

Nie, to niemożliwe. Będziesz musiał zachować ciąg i połączyć go, jeśli chcesz to wszystko w jednej linii, lub umieścić swoje wyjście w innym miejscu (powiedzmy, w innym oknie).

W NodeJS możesz użyć process.stdout.write i możesz dodać '\ n', jeśli chcesz.

console.log(msg)jest równoważne process.stdout.write(msg + '\n').

Możesz włożyć tyle rzeczy, argumentsile chcesz:

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

Otrzymasz wszystkie dane wyjściowe w jednym wierszu z wbudowanymi odwołaniami do obiektów, a następnie możesz z tego miejsca upuścić ich inspektorów.

Tak, to możliwe (sprawdź demo poniżej) - implementując własną konsolę wirtualną na natywnej konsoli przeglądarki, a następnie synchronizując ją z prawdziwą.

To jest o wiele łatwiejsze niż się wydaje:

1. utrzymywać bufor wyświetlania (np. tablicę ciągów reprezentujących po jednej linii)
2. połączenie console.clear() przed napisaniem, aby usunąć wszelkie wcześniejsze treści
3. call console.log()(lub ostrzeżenie, błąd itp.), aby wypełnić konsolę zawartością z bufora wyświetlania

Właściwie robię to już od jakiegoś czasu. Krótka, prymitywna realizacja pomysłu byłaby podobna, ale nadal zdolna do animowania zawartości konsoli:

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

Z pewnością ma swoje wady podczas miksowania z bezpośrednią interakcją z konsolą i zdecydowanie może wyglądać brzydko - ale z pewnością ma swoje ważne zastosowania, których nie można osiągnąć bez niego.

Krótka odpowiedź brzmi: nie.

Ale

Jeśli twój przypadek użycia obejmuje próbę rejestrowania wiecznie zmieniających się danych, unikając rozdęcia konsoli, to jednym ze sposobów osiągnięcia tego (w niektórych przeglądarkach) byłoby użycie console.clear()przed każdym wyjściem.

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

Zauważ, że prawdopodobnie zepsułoby to jakiekolwiek inne funkcje rejestrowania, które miały miejsce w twojej aplikacji.

Zastrzeżenie: uznałbym to za hack.

Jeśli Twoim jedynym celem jest zatrzymanie drukowania w wielu wierszach, jednym ze sposobów jest zgrupowanie wartości, jeśli nie chcesz, aby wypełniały całą konsolę

PS: - Do zobaczenia w konsoli przeglądarki do wyjścia

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


console.groupCollapsed('index')

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

console.groupEnd()

console.group

console.groupCollapsed

Coś o pomyśle @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();

zbierz dane wyjściowe w tablicy, a następnie użyj funkcji łączenia z preferowanym separatorem

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

echo("apple",3)

sprawdź również Array.prototype.join (), aby uzyskać szczegółowe informacje o trybie

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

Aby wyświetlić dane wyjściowe w jednym wierszu, można użyć operatora spreadu. Nowa funkcja javascript ES6. patrz poniższy przykład

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

Spowoduje to wydrukowanie od 1 do 10 tabel w jednej linii.

jeśli chcesz, na przykład, elementy tablicy dziennika konsoli bez znaku nowej linii, możesz to zrobić w ten sposób

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