Comment puis-je trouver la longueur d'un nombre?

Je cherche à obtenir la longueur d'un nombre en JavaScript ou jQuery?

J'ai essayé value.lengthsans succès, dois-je d'abord convertir cela en chaîne?

var x = 1234567;

x.toString().length;

Ce processus fonctionnera également pour Float Numberet pour Exponential numberaussi.

Ok, tant de réponses, mais c'est une question de mathématiques pures, juste pour le plaisir ou pour se rappeler que les mathématiques sont importantes:

var len = Math.ceil(Math.log(num + 1) / Math.LN10);

Cela donne en fait la "longueur" du nombre même s'il est sous forme exponentielle. numest censé être un entier non négatif ici: s'il est négatif, prenez sa valeur absolue et ajustez le signe par la suite.

Mise à jour pour ES2015

Maintenant que Math.log10c'est une chose , tu peux simplement écrire

const len = Math.ceil(Math.log10(num + 1));

J'ai utilisé cette fonctionnalité dans node.js, c'est mon implémentation la plus rapide à ce jour:

var nLength = function(n) { 
    return (Math.log(Math.abs(n)+1) * 0.43429448190325176 | 0) + 1; 
}

Il doit gérer les entiers positifs et négatifs (également sous forme exponentielle) et doit renvoyer la longueur de la partie entière en flottants.

La référence suivante devrait fournir un aperçu de la méthode: Weisstein, Eric W. «Number Length». De MathWorld - Une ressource Web Wolfram.

Je crois qu'une opération au niveau du bit peut remplacer Math.abs, mais jsperf montre que Math.abs fonctionne très bien dans la majorité des moteurs js.

Mise à jour : comme indiqué dans les commentaires, cette solution présente quelques problèmes :(

Update2 (solution de contournement) : Je crois qu'à un moment donné, des problèmes de précision surviennent et que le Math.log(...)*0.434...se comporte de manière inattendue. Cependant, si Internet Explorer ou les appareils mobiles ne sont pas votre tasse de thé, vous pouvez remplacer cette opération par la Math.log10fonction. Dans Node.js, j'ai écrit un test de base rapide avec la fonction nLength = (n) => 1 + Math.log10(Math.abs(n) + 1) | 0;et avec Math.log10cela a fonctionné comme prévu. Veuillez noter que ce Math.log10n'est pas universellement pris en charge.

Vous devez faire le nombre en chaîne pour prendre de la longueur

var num = 123;

alert((num + "").length);

ou

alert(num.toString().length);

Pourrait également utiliser une chaîne de modèle:

const num = 123456
`${num}`.length // 6

Eh bien, sans convertir l'entier en chaîne, vous pouvez créer une boucle funky:

var number = 20000;
var length = 0;
for(i = number; i > 1; ++i){
     ++length;
     i = Math.floor(i/10);
}

alert(length);​

Démo: http://jsfiddle.net/maniator/G8tQE/

Commencez par le convertir en chaîne:

var mynumber = 123;
alert((""+mynumber).length);

L'ajout d'une chaîne vide à celui-ci entraînera implicitement mynumbersa transformation en chaîne.

Il y a trois façons de procéder.

var num = 123;
alert(num.toString().length);

meilleure performance (meilleure performance dans ie11)

var num = 123;
alert((num + '').length);

Math (meilleures performances dans Chrome, Firefox mais plus lentes dans ie11)

var num = 123
alert(Math.floor( Math.log(num) / Math.LN10 ) + 1)

il y a un jspref ici http://jsperf.com/fastest-way-to-get-the-first-in-a-number/2

Vous devriez opter pour le plus simple (stringLength), la lisibilité bat toujours la vitesse. Mais si vous vous souciez de la vitesse, voici quelques exemples ci-dessous.

Trois méthodes différentes, toutes à vitesse variable.

// 34ms
let weissteinLength = function(n) { 
    return (Math.log(Math.abs(n)+1) * 0.43429448190325176 | 0) + 1;
}

// 350ms
let stringLength = function(n) {
    return n.toString().length;
}

// 58ms
let mathLength = function(n) {
    return Math.ceil(Math.log(n + 1) / Math.LN10);
}

// Simple tests below if you care about performance.

let iterations = 1000000;
let maxSize = 10000;

// ------ Weisstein length.

console.log("Starting weissteinLength length.");
let startTime = Date.now();

for (let index = 0; index < iterations; index++) {
    weissteinLength(Math.random() * maxSize);
}

console.log("Ended weissteinLength length. Took : " + (Date.now() - startTime ) + "ms");


// ------- String length slowest.

console.log("Starting string length.");
startTime = Date.now();

for (let index = 0; index < iterations; index++) {
    stringLength(Math.random() * maxSize);
}

console.log("Ended string length. Took : " + (Date.now() - startTime ) + "ms");


// ------- Math length.

console.log("Starting math length.");
startTime = Date.now();

for (let index = 0; index < iterations; index++) {
    mathLength(Math.random() * maxSize);
}

On m'a posé une question similaire lors d'un test.

Trouver la longueur d'un nombre sans convertir en chaîne

const numbers = [1, 10, 100, 12, 123, -1, -10, -100, -12, -123, 0, -0]

const numberLength = number => {

  let length = 0
  let n = Math.abs(number)

  do {
    n /=  10
    length++
  } while (n >= 1)

  return length
}

console.log(numbers.map(numberLength)) // [ 1, 2, 3, 2, 3, 1, 2, 3, 2, 3, 1, 1 ]

Des nombres négatifs ont été ajoutés pour le compliquer un peu plus, d'où Math.abs ().

Je voudrais corriger la réponse @Neal qui était assez bonne pour les entiers, mais le nombre 1 renverrait une longueur de 0 dans le cas précédent.

function Longueur(numberlen)
{
    var length = 0, i; //define `i` with `var` as not to clutter the global scope
    numberlen = parseInt(numberlen);
    for(i = numberlen; i >= 1; i)
    {
        ++length;
        i = Math.floor(i/10);
    }
    return length;
}

Essaye ça:

$("#element").text().length;

Exemple d'utilisation

Oui, vous devez convertir en chaîne pour trouver la longueur, par exemple

var x=100;// type of x is number
var x=100+"";// now the type of x is string
document.write(x.length);//which would output 3.