Qual é a melhor maneira de converter um número em uma string em JavaScript?

Qual é a melhor maneira de converter um número em uma string (em termos de vantagem de velocidade, vantagem de clareza, vantagem de memória etc.)?

Alguns exemplos:

1. String(n)

2. n.toString()

3. ""+n

4. n+""

como isso:

var foo = 45;
var bar = '' + foo;

Na verdade, embora eu normalmente faça isso dessa maneira por conveniência simples, mais de 1.000s de iterações parecem velocidade bruta, há uma vantagem para.toString()

Consulte Testes de desempenho aqui (não por mim, mas encontrado quando fui escrever o meu): http://jsben.ch/#/ghQYR

Mais rápido com base no teste JSPerf acima: str = num.toString();

Deve-se notar que a diferença de velocidade não é excessivamente significativa quando você considera que pode fazer a conversão de qualquer maneira 1 milhão de vezes em 0,1 segundos .

Atualização: a velocidade parece variar bastante de acordo com o navegador. No Chrome, num + ''parece ser o mais rápido com base neste teste http://jsben.ch/#/ghQYR

Atualização 2: Novamente, com base no meu teste acima, observe que o Firefox 20.0.1 executa .toString()cerca de 100 vezes mais devagar que a '' + numamostra.

Na minha opinião, n.toString()leva o prêmio por sua clareza, e não acho que isso acarreta custos adicionais.

Conversões explícitas são muito claras para alguém que é novo no idioma. O uso de coerção de tipo, como outros sugeriram, leva à ambiguidade se um desenvolvedor não estiver ciente das regras de coerção. Em última análise, o tempo do desenvolvedor é mais caro do que o tempo da CPU, então eu otimizaria para o primeiro ao custo do último. Dito isto, neste caso, a diferença é provavelmente insignificante, mas se não, tenho certeza de que existem alguns compressores JavaScript decentes que otimizarão esse tipo de coisa.

Portanto, pelas razões acima, eu usaria: n.toString()ou String(n). String(n)provavelmente é uma escolha melhor porque não falhará se nfor nulo ou indefinido.

... O analisador de JavaScript tenta analisar a notação de ponto em um número como um literal de ponto flutuante.

2..toString(); // the second point is correctly recognized
2 .toString(); // note the space left to the dot
(2).toString(); // 2 is evaluated first

Fonte

Língua na bochecha, obviamente:

var harshNum = 108;
"".split.call(harshNum,"").join("");

Ou no ES6, você pode simplesmente usar seqüências de caracteres de modelo :

var harshNum = 108;
`${harshNum}`;

Outras respostas já cobriam outras opções, mas eu prefiro esta:

s = `${n}`

Curto, sucinto, já usado em muitos outros lugares (se você estiver usando uma estrutura moderna / versão ES), por isso é uma aposta segura que qualquer programador entenderá.

Não que isso (geralmente) tenha muita importância, mas também parece estar entre os mais rápidos em comparação com outros métodos .

A maneira mais simples de converter qualquer variável em uma string é adicionar uma string vazia a essa variável.

5.41 + ''    // Result: the string '5.41'
Math.PI + '' // Result: the string '3.141592653589793'

Se você precisar formatar o resultado para um número específico de casas decimais, por exemplo, para representar a moeda, precisará de algo como o toFixed()método

number.toFixed( [digits] )

digits é o número de dígitos a serem exibidos após a casa decimal.

Usei https://jsperf.com para criar um caso de teste para os seguintes casos:

number + ''
`${number}`
String(number)
number.toString()

https://jsperf.com/number-string-conversion-speed-comparison

Em 24 de julho de 2018, os resultados dizem que number + '' é o mais rápido no Chrome, no Firefox, vinculado a literais de cadeias de caracteres de modelo.

Ambos String(number)e number.toString()são cerca de 95% mais lentos que a opção mais rápida.

Gosto dos dois primeiros, pois são mais fáceis de ler. Eu costumo usarString(n) mas é apenas uma questão de estilo do que qualquer outra coisa.

Ou seja, a menos que você tenha uma linha como

var n = 5;
console.log ("the number is: " + n);

o que é muito auto-explicativo

Eu acho que depende da situação, mas de qualquer maneira você pode usar o .toString()método, pois é muito claro para entender.

.toString () é a função de conversão de texto incorporada, não sou especialista nesses detalhes, mas sempre que comparamos a conversão de tipos incorporada versus metodologias explícitas, as soluções internas sempre preferidas.

Se eu tivesse que levar tudo em consideração, sugerirei seguir

var myint = 1;
var mystring = myint + '';
/*or int to string*/
myint = myint + ''

IMHO, é a maneira mais rápida de converter para string. Corrija-me se eu estiver enganado.

A única solução válida para quase todos os casos existentes e futuros possíveis (entrada é número, nulo, indefinido, símbolo, qualquer outra coisa) éString(x) . Não use três maneiras de operação simples, baseando-se em suposições de tipo de valor, como "aqui eu converto definitivamente número em string e aqui definitivamente booleano em string".

Explicação:

String(x)lida com valores nulos, indefinidos, Símbolos [qualquer coisa] e solicita .toString()objetos.

'' + xchama .valueOf()x (conversão para número), lança Símbolos, pode fornecer resultados dependentes da implementação.

x.toString() lança nulos e indefinidos.

Nota: String(x)ainda falhará em objetos sem protótipo, como Object.create(null).

Se você não gosta de strings como 'Hello, undefined' ou deseja oferecer suporte a objetos sem protótipo, use a seguinte função de conversão de tipo:

/**
 * Safely casts any value to string. Null and undefined are converted to ''.
 * @param  {*} value
 * @return {string}
 */
function string (str) {
  return value == null ? '' : (typeof value === 'object' && !value.toString ? '[object]' : String(value));
}

Com literais numéricos, o ponto para acessar uma propriedade deve ser diferenciado do ponto decimal. Isso deixa você com as seguintes opções se desejar chamar String () no número literal 123:

123..toString()
123 .toString() // space before the dot 123.0.toString()
(123).toString()

A seguir estão os métodos para converter um Número Inteiro em String em JS

Os métodos são organizados na ordem decrescente de desempenho.

(Os resultados dos testes de desempenho são dados por @DarckBlezzer em sua resposta)

var num = 1

Método 1:

num = `$ {num}`

Método 2:

num = num + ''

Método 3:

num = String (num)

Método 4:

num = num.toString ()

Nota: Você não pode ligar diretamente para tostring () de um número

Por exemplo: 2.toString () lançará Untaught SyntaxError : token inválido ou inesperado

Se você está curioso para saber qual é o melhor desempenho, verifique isso onde eu comparo todas as diferentes conversões Number -> String.

Parece 2+''ou 2+""é o mais rápido.

https://jsperf.com/int-2-string

Também podemos usar o construtor String . De acordo com esse benchmark , é a maneira mais rápida de converter um número em string no Firefox 58, embora seja mais lento que " + numno navegador popular Google Chrome.

O método toFixed()também resolve o objetivo.

var n = 8.434332;
n.toFixed(2)  // 8.43

Você pode chamar o Numberobjeto e depois chamar toString().

Number.call(null, n).toString()

Você pode usar esse truque para outros objetos nativos javascript.

Apenas deparei com isso recentemente, os métodos 3 e 4 não são apropriados, porque a maneira como as seqüências de caracteres são copiadas e depois montadas. Para um programa pequeno, esse problema é insignificante, mas para qualquer aplicativo Web real, essa ação em que precisamos lidar com manipulações de strings de frequência pode afetar o desempenho e a legibilidade.

Aqui está o link da leitura .

Vou reeditar isso com mais dados quando tiver tempo, pois agora está tudo bem ...

Teste no nodejs v8.11.2: 06/06/2018

let i=0;
    console.time("test1")
    for(;i<10000000;i=i+1){
    	const string = "" + 1234;
    }
    console.timeEnd("test1")
    
    i=0;
    console.time("test1.1")
    for(;i<10000000;i=i+1){
    	const string = '' + 1234;
    }
    console.timeEnd("test1.1")
    
    i=0;
    console.time("test1.2")
    for(;i<10000000;i=i+1){
    	const string = `` + 1234;
    }
    console.timeEnd("test1.2")
    
    i=0;
    console.time("test1.3")
    for(;i<10000000;i=i+1){
    	const string = 1234 +  '';
    }
    console.timeEnd("test1.3")
    
    
    i=0;
    console.time("test2")
    for(;i<10000000;i=i+1){
    	const string = (1234).toString();
    }
    console.timeEnd("test2")
    
    
    i=0;
    console.time("test3")
    for(;i<10000000;i=i+1){
    	const string = String(1234);
    }
    console.timeEnd("test3")
    
    
    i=0;
    console.time("test4")
    for(;i<10000000;i=i+1){
    	const string = `${1234}`;
    }
    console.timeEnd("test4")
    
    i=0;
    console.time("test5")
    for(;i<10000000;i=i+1){
    	const string = 1234..toString();
    }
    console.timeEnd("test5")
    
    i=0;
    console.time("test6")
    for(;i<10000000;i=i+1){
    	const string = 1234 .toString();
    }
    console.timeEnd("test6")

resultado

test1: 72.268ms
test1.1: 61.086ms
test1.2: 66.854ms
test1.3: 63.698ms
test2: 207.912ms
test3: 81.987ms
test4: 59.752ms
test5: 213.136ms
test6: 204.869ms

Parece resultados semelhantes ao usar o node.js. Eu executei este script:

let bar;
let foo = ["45","foo"];

console.time('string concat testing');
for (let i = 0; i < 10000000; i++) {
    bar = "" + foo;
}
console.timeEnd('string concat testing');


console.time("string obj testing");
for (let i = 0; i < 10000000; i++) {
    bar = String(foo);
}
console.timeEnd("string obj testing");

console.time("string both");
for (let i = 0; i < 10000000; i++) {
    bar = "" + foo + "";
}
console.timeEnd("string both");

e obteve os seguintes resultados:

❯ node testing.js
string concat testing: 2802.542ms
string obj testing: 3374.530ms
string both: 2660.023ms

Tempos similares cada vez que eu o executei.