Console développeur JavaScript Chrome: est-il possible d'appeler console.log () sans nouvelle ligne?

Je voudrais utiliser console.log () pour enregistrer des messages sans ajouter de nouvelle ligne après chaque appel à console.log (). Est-ce possible?

Non, ce n'est pas possible. Vous devrez conserver une chaîne et concaténer si vous voulez tout sur une seule ligne, ou placer votre sortie ailleurs (par exemple, une autre fenêtre).

Dans NodeJS, vous pouvez utiliser process.stdout.write et vous pouvez ajouter '\ n' si vous le souhaitez.

console.log(msg)équivaut à process.stdout.write(msg + '\n').

Vous pouvez mettre autant de choses argumentsque vous le souhaitez:

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

Vous obtiendrez toute cette sortie sur une ligne avec les références d'objet en ligne et vous pourrez ensuite déposer leurs inspecteurs à partir de là.

Oui c'est possible (consultez la démo ci-dessous) - en implémentant votre propre console virtuelle au-dessus de la console native du navigateur, puis en la synchronisant avec la vraie.

C'est beaucoup plus facile qu'il n'y paraît:

1. maintenir un tampon d'affichage (par exemple un tableau de chaînes représentant une ligne chacune)
2. appeler console.clear()avant d'écrire pour effacer tout contenu précédent
3. appeler console.log()(ou avertir, erreur, etc.) pour remplir la console avec le contenu de votre tampon d'affichage

En fait, je fais ça depuis un certain temps maintenant. Une implémentation courte et rudimentaire de l'idée serait quelque chose du genre suivant, mais toujours capable d' animer le contenu de la 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);

Il a certainement ses inconvénients lors du mixage avec une interaction directe avec la console, et peut certainement paraître moche - mais il a certainement ses utilisations valables, que vous ne pourriez pas réaliser sans lui.

La réponse courte est non.

Mais

Si votre cas d'utilisation consiste à tenter de consigner des données en perpétuel changement tout en évitant le gonflement de la console, une façon d'y parvenir (dans certains navigateurs) serait de l'utiliser console.clear()avant chaque sortie.

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

Notez que cela interromprait probablement toute autre fonctionnalité de journalisation qui se déroulait dans votre application.

Avertissement: je classerais cela comme un hack.

Si votre seul but est d'arrêter l'impression sur plusieurs lignes, une façon est de regrouper les valeurs si vous ne voulez pas qu'elles remplissent votre console complète

PS: - Voir la console de votre navigateur pour la sortie

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


console.groupCollapsed('index')

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

console.groupEnd()

console.group

console.groupCollapsed

Quelque chose à propos de l'idée @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();

collectez votre sortie dans un tableau, puis utilisez la fonction de jointure avec un séparateur préféré

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

echo("apple",3)

vérifiez également Array.prototype.join () pour les détails du mode

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

Vous pouvez utiliser un opérateur d'étalement pour afficher la sortie sur une seule ligne. La nouvelle fonctionnalité de javascript ES6. voir l'exemple ci-dessous

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

Cela imprimera 1 à 10 tableaux en une seule ligne.

si vous voulez par exemple des éléments de tableau de journal de console sans nouvelle ligne, vous pouvez faire comme ceci

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