Console per sviluppatori JavaScript di Chrome: è possibile chiamare console.log () senza una nuova riga?

Vorrei utilizzare console.log () per registrare i messaggi senza aggiungere una nuova riga dopo ogni chiamata a console.log (). È possibile?

No, non è possibile. Dovrai mantenere una stringa e concatenare se vuoi tutto in una riga, o mettere il tuo output altrove (diciamo, un'altra finestra).

In NodeJS puoi usare process.stdout.write e puoi aggiungere '\ n' se vuoi.

console.log(msg)è equivalente a process.stdout.write(msg + '\n').

Puoi inserire tutte le cose argumentsche desideri:

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

Otterrai tutto l'output su una riga con i riferimenti all'oggetto inline e potrai quindi visualizzare i loro ispettori da lì.

Si è possibile (controlla la demo di seguito), implementando la tua console virtuale sulla console del browser nativa, quindi sincronizzandola con quella reale.

Questo è molto più facile di quanto sembri:

1. mantenere un buffer di visualizzazione (ad esempio un array di stringhe che rappresentano una riga ciascuna)
2. chiamare console.clear()prima di scrivere per cancellare eventuali contenuti precedenti
3. call console.log()(o warn, error, ecc.) per riempire la console con i contenuti dal tuo buffer di visualizzazione

In realtà, lo sto facendo da un po 'di tempo. Una breve e rudimentale implementazione dell'idea sarebbe qualcosa del genere, ma comunque in grado di animare i contenuti della console:

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

Sicuramente ha i suoi svantaggi quando si mescola con l'interazione diretta della console e può sicuramente sembrare brutto, ma ha certamente i suoi usi validi, che non potresti ottenere senza di esso.

La risposta breve è no.

Ma

Se il tuo caso d'uso prevede il tentativo di registrare dati in continua evoluzione evitando il sovraccarico della console, un modo per ottenere ciò (in alcuni browser) sarebbe quello di utilizzare console.clear()prima di ogni output.

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

Si noti che questo probabilmente interromperà qualsiasi altra funzionalità di registrazione che si stava verificando all'interno dell'applicazione.

Disclaimer: lo classificherei come un hack.

Se il tuo unico scopo è interrompere la stampa su molte righe, un modo è raggruppare i valori se non vuoi che riempiano la tua console completa

PS: - Ci vediamo nella console del browser per l'output

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


console.groupCollapsed('index')

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

console.groupEnd()

console.group

console.groupCollapsed

Qualcosa sull'idea di @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();

raccogliere l'output in un array e quindi utilizzare la funzione di unione con un separatore preferito

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

echo("apple",3)

controlla anche Array.prototype.join () per i dettagli sulla modalità

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

È possibile utilizzare un operatore di diffusione per visualizzare l'output su un'unica riga. La nuova funzionalità di javascript ES6. vedi esempio sotto

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

Ciò stamperà da 1 a 10 tabelle in una sola riga.

se vuoi, ad esempio, gli elementi dell'array di log della console senza una nuova riga, puoi fare così

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