Console do desenvolvedor JavaScript do Chrome: é possível chamar console.log () sem uma nova linha?

Eu gostaria de usar console.log () para registrar mensagens sem acrescentar uma nova linha após cada chamada para console.log (). Isso é possível?

Não, não é possível. Você terá que manter uma string e concatenar se quiser tudo em uma linha ou colocar sua saída em outro lugar (digamos, outra janela).

No NodeJS você pode usar process.stdout.write e adicionar '\ n' se quiser.

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

Você pode colocar quantas coisas argumentsquiser:

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

Você obterá toda a saída em uma linha com as referências de objeto embutidas e poderá então abrir seus inspetores a partir daí.

Sim, é possível (verifique a demonstração abaixo) - implementando seu próprio console virtual em cima do console do navegador nativo e sincronizando-o com o real.

Isso é muito mais fácil do que parece:

1. manter um buffer de exibição (por exemplo, uma matriz de strings representando uma linha cada)
2. ligue console.clear()antes de escrever para apagar qualquer conteúdo anterior
3. chamar console.log()(ou avisar, erro, etc) para preencher o console com o conteúdo de seu buffer de exibição

Na verdade, já faço isso há algum tempo. Uma implementação curta e rudimentar da ideia seria algo nas seguintes linhas, mas ainda capaz de animar o conteúdo do 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);

Com certeza tem suas desvantagens quando se mistura com a interação direta do console e pode definitivamente parecer feio - mas certamente tem seus usos válidos, que você não conseguiria sem ele.

A resposta curta é não.

Mas

Se o seu caso de uso envolver a tentativa de registrar dados que mudam perpetuamente, evitando o inchaço do console, uma maneira de conseguir isso (em certos navegadores) seria usar console.clear()antes de cada saída.

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

Observe que isso provavelmente interromperia qualquer outra funcionalidade de registro que estivesse ocorrendo em seu aplicativo.

Aviso: Eu classificaria isso como um hack.

Se o seu único propósito é parar de imprimir em muitas linhas, uma maneira é agrupar os valores se você não quiser que eles ocupem todo o console

PS: - Veja o console do seu navegador para saída

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


console.groupCollapsed('index')

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

console.groupEnd()

console.group

console.groupCollapsed

Algo sobre a ideia @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();

colete sua saída em uma matriz e, em seguida, use a função de junção com um separador preferido

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

echo("apple",3)

verifique também Array.prototype.join () para detalhes do modo

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

Você pode usar um operador de propagação para exibir a saída em uma única linha. O novo recurso do javascript ES6. veja o exemplo abaixo

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

Isso imprimirá de 1 a 10 tabelas em uma única linha.

se você quiser, por exemplo, elementos da matriz de log do console sem uma nova linha você pode fazer assim

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