Question Vérifiez si la variable est un numéro ou une chaîne en JavaScript


Est-ce que quelqu'un sait comment je peux vérifier si une variable est un nombre ou une chaîne dans JavaScript?


413
2017-08-20 02:23


origine


Réponses:


Si vous traitez de la notation littérale, et non des constructeurs, vous pouvez utiliser Type de:.

typeof "Hello World"; // string
typeof 123;           // number

Si vous créez des nombres et des chaînes via un constructeur, par exemple var foo = new String("foo"), vous devriez garder à l'esprit que typeof peut retourner object pour foo.

Peut-être une méthode plus infaillible de vérifier le type serait d'utiliser la méthode trouvée dans underscore.js (source annotée peut être trouvé ici),

var toString = Object.prototype.toString;

_.isString = function (obj) {
  return toString.call(obj) == '[object String]';
}

Cela renvoie un booléen true pour la suite:

_.isString("Jonathan"); // true
_.isString(new String("Jonathan")); // true

399
2017-08-20 02:25



La meilleure façon de faire est d'utiliser la conversion de type isNaN +:

Méthode all-in mise à jour:

function isNumber(n) { return !isNaN(parseFloat(n)) && !isNaN(n - 0) }

La même chose en utilisant regex:

function isNumber(n) { return /^-?[\d.]+(?:e-?\d+)?$/.test(n); } 

------------------------

isNumber ('123'); // true  
isNumber ('123abc'); // true  
isNumber (5); // true  
isNumber ('q345'); // false
isNumber(null); // false
isNumber(undefined); // false
isNumber(false); // false
isNumber('   '); // false

177
2018-01-13 16:48



Le meilleur moyen que j'ai trouvé est soit de vérifier une méthode sur la chaîne, à savoir:

if (x.substring) {
// do string thing
} else{
// do other thing
}

ou si vous voulez faire quelque chose avec le contrôle de nombre pour une propriété de nombre,

if (x.toFixed) {
// do number thing
} else {
// do other thing
}

C'est un peu comme le "typage du canard", c'est à vous de décider quel est le plus logique. Je n'ai pas assez de karma pour commenter, mais typeof échoue pour les chaînes et les nombres encadrés, c'est-à-dire:

alert(typeof new String('Hello World'));
alert(typeof new Number(5));

alertera "objet".


72
2018-03-15 22:26



Vérifiez si la valeur est un littéral de chaîne ou un objet String:

function isString(o) {
    return typeof o == "string" || (typeof o == "object" && o.constructor === String);
}

Test de l'unité:

function assertTrue(value, message) {
    if (!value) {
        alert("Assertion error: " + message);
    }
}

function assertFalse(value, message)
{
    assertTrue(!value, message);
}

assertTrue(isString("string literal"), "number literal");
assertTrue(isString(new String("String object")), "String object");
assertFalse(isString(1), "number literal");
assertFalse(isString(true), "boolean literal");
assertFalse(isString({}), "object");

La vérification d'un nombre est similaire:

function isNumber(o) {
    return typeof o == "number" || (typeof o == "object" && o.constructor === Number);
}

27
2017-08-20 02:50



Vous recherchez isNaN ():

<script type="text/javascript">
  alert(isNaN(123));
  alert(isNaN(-1.23));
  alert(isNaN(5-2));
  alert(isNaN(0));
  alert(isNaN("Hello"));
  alert(isNaN("2005/12/12"));
</script>

Voir JavaScript isNaN () Fonction chez MDN.


22
2017-08-20 02:38



Essaye ça,

<script>
var regInteger = /^\d+$/;

function isInteger( str ) {    
    return regInteger.test( str );
}

if(isInteger("1a11")) {
   console.log( 'Integer' );
} else {
   console.log( 'Non Integer' );
}
</script>

17
2018-04-10 17:59



Depuis ES2015, la bonne façon de vérifier si une variable détient un nombre valide est:

Number.isFinite(value)

Exemples:

Number.isFinite(Infinity)   // false
Number.isFinite(NaN)        // false
Number.isFinite(-Infinity)  // false

Number.isFinite(0)          // true
Number.isFinite(2e64)       // true

Number.isFinite('0')        // false
Number.isFinite(null)       // false

15
2018-05-24 16:59



//testing data types accurately in JavaScript (opposed to "typeof")
//from http://bonsaiden.github.com/JavaScript-Garden/
function is(type, obj) {
    var clas = Object.prototype.toString.call(obj).slice(8, -1);
    return obj !== undefined && obj !== null && clas === type;
}

//basic usage
is('String', 'test'); // true
is('Array', true); // false

Ou l'adapter pour renvoyer un type inconnu:

function realTypeOf(obj) {
    return Object.prototype.toString.call(obj).slice(8, -1);
}

//usage
realTypeOf(999); // 'Number'

Mise à jour le 12 mai 2012: Exemple complet à Javascript: Un meilleur typeof.


13
2017-08-25 19:14



Le meilleur moyen de le faire:

function isNumber(num) {
  return (typeof num == 'string' || typeof num == 'number') && !isNaN(num - 0) && num !== '';
};

Cela satisfait les cas de test suivants:

assertEquals("ISNUMBER-True: 0", true, isNumber(0));
assertEquals("ISNUMBER-True: 1", true, isNumber(-1));
assertEquals("ISNUMBER-True: 2", true, isNumber(-500));
assertEquals("ISNUMBER-True: 3", true, isNumber(15000));
assertEquals("ISNUMBER-True: 4", true, isNumber(0.35));
assertEquals("ISNUMBER-True: 5", true, isNumber(-10.35));
assertEquals("ISNUMBER-True: 6", true, isNumber(2.534e25));
assertEquals("ISNUMBER-True: 7", true, isNumber('2.534e25'));
assertEquals("ISNUMBER-True: 8", true, isNumber('52334'));
assertEquals("ISNUMBER-True: 9", true, isNumber('-234'));

assertEquals("ISNUMBER-False: 0", false, isNumber(NaN));
assertEquals("ISNUMBER-False: 1", false, isNumber({}));
assertEquals("ISNUMBER-False: 2", false, isNumber([]));
assertEquals("ISNUMBER-False: 3", false, isNumber(''));
assertEquals("ISNUMBER-False: 4", false, isNumber('one'));
assertEquals("ISNUMBER-False: 5", false, isNumber(true));
assertEquals("ISNUMBER-False: 6", false, isNumber(false));
assertEquals("ISNUMBER-False: 7", false, isNumber());
assertEquals("ISNUMBER-False: 8", false, isNumber(undefined));
assertEquals("ISNUMBER-False: 9", false, isNumber(null));

11
2018-06-17 05:55



Voici une approche basée sur l'idée de contraindre l'entrée à un nombre ou une chaîne en ajoutant zéro ou la chaîne nulle, puis faites une comparaison d'égalité typée.

function is_number(x) { return x === x+0;  }
function is_string(x) { return x === x+""; }

Pour une raison insondable, x===x+0 semble fonctionner mieux que x===+x.

Y a-t-il des cas où cela échoue?

Dans la même veine:

function is_boolean(x) { return x === !!x; }

Cela semble être légèrement plus rapide que l'un ou l'autre x===true || x===false ou typeof x==="boolean" (et beaucoup plus vite que x===Boolean(x)).

Ensuite, il y a aussi

function is_regexp(x)  { return x === RegExp(x); }

Tout ceci dépend de l'existence d'une opération "identité" propre à chaque type qui peut s'appliquer à n'importe quelle valeur et produire de façon fiable une valeur du type en question. Je ne peux pas penser à une telle opération pour les dates.

Pour NaN, il y a

function is_nan(x) { return x !== x;}

Ceci est fondamentalement la version de soulignement, et tel quel est environ quatre fois plus rapide que isNaN(), mais les commentaires dans la source de soulignement mentionnent que "NaN est le seul nombre ça ne s'égale pas "et ajoute une vérification de _.isNumber .Pourquoi? Quels autres objets ne seraient pas égaux? x !== +x- mais quelle différence pourrait le + fais-le ici?

Alors pour le paranoïaque:

function is_undefined(x) { return x===[][0]; }

8
2018-03-06 11:01



Pouvez-vous simplement le diviser par 1?

Je suppose que le problème serait une entrée de chaîne comme: "123ABG"

var Check = "123ABG"

if(Check == Check / 1)
{
alert("This IS a number \n")
}

else
{
alert("This is NOT a number \n")
}

Juste comme je l'ai fait récemment.


7
2017-10-20 18:19