Consola de desarrollador de JavaScript de Chrome: ¿Es posible llamar a console.log () sin una nueva línea?

Me gustaría usar console.log () para registrar mensajes sin agregar una nueva línea después de cada llamada a console.log (). es posible?

No, no es posible. Tendrá que mantener una cadena y concatenar si lo desea todo en una línea, o poner su salida en otro lugar (digamos, otra ventana).

En NodeJS puede usar process.stdout.write y puede agregar '\ n' si lo desea.

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

Puedes poner tantas cosas argumentscomo quieras:

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

Obtendrá toda esa salida en una línea con las referencias de objeto en línea y luego puede desplegar sus inspectores desde allí.

Sí, es posible (consulte la demostración a continuación): implementando su propia consola virtual en la parte superior de la consola del navegador nativo y luego sincronizándola con la real.

Esto es mucho más fácil de lo que parece:

1. mantener un búfer de visualización (por ejemplo, una matriz de cadenas que representan una línea cada una)
2. llamar console.clear()antes de escribir para borrar cualquier contenido anterior
3. llamar console.log()(o advertir, error, etc.) para llenar la consola con el contenido de su búfer de pantalla

De hecho, he estado haciendo esto por algún tiempo. Una implementación breve y rudimentaria de la idea sería algo en la siguiente línea, pero aún capaz de animar el contenido de la consola:

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

Seguro que tiene sus inconvenientes cuando se mezcla con la interacción directa de la consola, y definitivamente puede verse feo, pero ciertamente tiene sus usos válidos, que no podrías lograr sin él.

La respuesta corta es no.

Pero

Si su caso de uso implica intentar registrar datos que cambian perpetuamente mientras evita la sobrecarga de la consola, entonces una forma de lograrlo (en ciertos navegadores) sería usar console.clear()antes de cada salida.

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

Tenga en cuenta que esto probablemente interrumpiría cualquier otra funcionalidad de registro que estuviera teniendo lugar dentro de su aplicación.

Descargo de responsabilidad: clasificaría esto como un truco.

Si su único propósito es dejar de imprimir en muchas líneas, una forma es agrupar los valores si no desea que llenen su consola completa

PD: - Ver la consola del navegador para ver la salida

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 la idea de @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();

recopile su salida en una matriz y luego use la función de unión con un 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 también Array.prototype.join () para detalles del 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

Puede utilizar un operador de extensión para mostrar la salida en una sola línea. La nueva función de javascript ES6. ver el siguiente ejemplo

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

Eso imprimirá de 1 a 10 tablas en una sola línea.

si desea, por ejemplo, elementos de matriz de registro de la consola sin una nueva línea, puede hacer esto

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