Comment vérifier une chaîne vide / indéfinie / nulle en JavaScript?

Question

J'ai vu ce fil , mais je n'a pas vu un exemple spécifique à JavaScript. Existe-t-il un simple string.Empty disponible en JavaScript ou s'agit-il simplement d'une vérification de "" ?

Answer 1

Si vous voulez juste vérifier s'il y a une valeur, vous pouvez le faire

if (strValue) {
    //do something
}

Si vous devez rechercher spécifiquement une chaîne vide sur null, je pense que vérifier avec "" est votre meilleur choix, utilisez l'opérateur === (afin que vous sachiez qu'il s'agit en fait d'une chaîne avec laquelle vous faites la comparaison ).

if (strValue === "") {
    //...
}

Answer 2

Pour vérifier si une chaîne est vide, nulle ou non définie, j'utilise:

function isEmpty(str) {
    return (!str || 0 === str.length);
}

Pour vérifier si une chaîne est vide, nulle ou non définie, j'utilise:

function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

Pour vérifier si une chaîne est vide ou ne contient que des espaces:

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};

Answer 3

Tout ce qui précède est bon mais ce sera encore mieux utilisez l'opérateur !! ( not not ).

if(!!str){
some code here;
}

ou utilisez le transtypage:

if(Boolean(str)){
    codes here;
}

Les deux font la même fonction, tapez la variable booléenne, où str est une variable.
Renvoie false pour null, undefined, 0,000, "quot", false .
Renvoie true pour la chaîne " 0 " et les espaces " ".

Answer 4

Si vous devez vous assurer que la chaîne n'est pas qu'un tas d'espaces vides (je suppose que c'est pour la validation de formulaire), vous devez effectuer un remplacement sur les espaces.

if(str.replace(/\s/g,"") == ""){
}

Answer 5

L'élément le plus proche de str.Empty (avec la condition préalable que str soit une chaîne) est:

if (!str.length) { ...

Answer 6

j'utilise:

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case typeof this == "undefined":
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
  })) // false

Answer 7

Essayez:

if (str && str.trim().length) {  
    //...
}

Answer 8

Fonction:

function is_empty(x)
{
   return ( 
        (typeof x == 'undefined')
                    ||
        (x == null) 
                    ||
        (x == false)  //same as: !x
                    ||
        (x.length == 0)
                    ||
        (x == "")
                    ||
        (x.replace(/\s/g,"") == "")
                    ||
        (!/[^\s]/.test(x))
                    ||
        (/^\s*$/.test(x))
  );
}

  

p.s. En Javascript, n'utilisez pas Line-Break après return ;

Answer 9

var s; // undefined
var s = ""; // ""
s.length // 0

Rien ne représente une chaîne vide en JavaScript. Effectuez une vérification sur longueur (si vous savez que la variable var sera toujours une chaîne) ou sur "quot

".

Answer 10

Vous pouvez utiliser lodash : _.isEmpty (valeur).

Cela couvre beaucoup de cas comme {} , '' , null , undefined etc.

Mais il renvoie toujours true pour le type Number de Types de données primitifs Javascript comme _. IsEmpty (10) ou _. IsEmpty (Number.MAX_VALUE) les deux renvoient < code> true .

Answer 11

Je ne voudrais pas trop m'inquiéter de la méthode la plus efficace . Utilisez ce qui est le plus clair pour votre intention. Pour moi, il s'agit généralement de strVar == "" .

EDIT: par commentaire de Constantin , si strVar pourrait contenir une valeur entière égale à 0, alors ce serait en effet être l'une de ces situations de clarification d'intention.

Answer 12

vous pouvez aussi aller avec les expressions rationnelles:

if((/^\s*$/).test(str)) { }

Recherche les chaînes vides ou remplies d'espaces.

Answer 13

Beaucoup de réponses et de nombreuses possibilités!

Sans aucun doute, pour une implémentation simple et rapide, le gagnant est: if (! str.length) {...}

Cependant, de nombreux autres exemples sont disponibles. La meilleure méthode fonctionnelle pour y parvenir, je suggérerais:

function empty(str)
{
    if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "")
    {
        return true;
    }
    else
    {
        return false;
    }
}

Un peu excessif, je sais.

Answer 14

1. vérifiez que var a; existe

2. éliminez les espaces vides dans la valeur, puis testez le vide

   if ((a)&&(a.trim()!=''))
   {
     // if variable a is not empty do this 
   }
   

Answer 15

De même, si vous considérez une chaîne remplie par un espace comme "vide". Vous pouvez le tester avec cette regex:

!/\S/.test(string); // Returns true if blank.

Answer 16

J'utilise habituellement quelque chose comme ça,

if (!str.length) {
//do some thing
}

Answer 17

Je n'ai pas remarqué de réponse prenant en compte la possibilité de caractères nuls dans une chaîne. Par exemple, si nous avons une chaîne de caractères nulle:

var y = "\0"; // an empty string, but has a null character
(y === "") // false, testing against an empty string does not work
(y.length === 0) // false
(y) // true, this is also not expected
(y.match(/^[\s]*$/)) // false, again not wanted

Pour tester sa validité, on pourrait faire quelque chose comme ceci:

String.prototype.isNull = function(){ 
  return Boolean(this.match(/^[\0]*$/)); 
}
...
"\0".isNull() // true

Cela fonctionne sur une chaîne NULL, sur une chaîne vide et il est accessible pour toutes les chaînes. De plus, il pourrait être étendu pour contenir d’autres caractères JavaScript vides ou espaces (par exemple, espace insécable, repère d’octet, séparateur de ligne / paragraphe, etc.).

Answer 18

S'il faut détecter non seulement les chaînes vides, mais également les chaînes vides, j'ajouterai à la réponse de Goral:

function isEmpty(s){
    return !s.length;    
}

function isBlank(s){
    return isEmpty(s.trim());    
}

Answer 19

Toutes ces réponses sont sympas.

Mais je ne peux pas être sûr que cette variable est une chaîne, qu'elle ne contient pas uniquement des espaces (c'est important pour moi) et qu'elle peut contenir '0' (chaîne).

Ma version:

function empty(str){
    return !str || !/[^\s]+/.test(str);
}

empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

Exemple sur jsfiddle .

Answer 20

J'utilise habituellement quelque chose comme:

if (str == "") {
     //Do Something
}
else {
     //Do Something Else
}

Answer 21

J'utilise une combinaison, les contrôles les plus rapides sont les premiers.

function isBlank(pString){
    if (!pString || pString.length == 0) {
        return true;
    }
    // checks for a non-white space character 
    // which I think [citation needed] is faster 
    // than removing all the whitespace and checking 
    // against an empty string
    return !/[^\s]+/.test(pString);
}

Answer 22

En ignorant les chaînes d'espaces, vous pouvez l'utiliser pour vérifier les valeurs nulles, vides et non définies:

var obj = {};
(!!obj.str) //returns false

obj.str = "";
(!!obj.str) //returns false

obj.str = null;
(!!obj.str) //returns false

Concis et fonctionne pour les propriétés non définies, bien que ce ne soit pas le plus lisible.

Answer 23

J'ai fait quelques recherches sur ce qui se passe si vous passez une valeur non-string et non-vide / null à une fonction testeur. Comme beaucoup le savent, (0 == "") est vrai en javascript, mais comme 0 est une valeur et non une valeur vide ou nulle, vous pouvez le tester.

Les deux fonctions suivantes ne renvoient vrai que pour les valeurs non définies, nulles, vides / espaces, et faux pour tout le reste, comme les nombres, les booléens, les objets, les expressions, etc.

function IsNullOrEmpty(value)
{
    return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
    return (value == null || !/\S/.test(value));
}

Des exemples plus complexes existent, mais ils sont simples et donnent des résultats cohérents. Il n'est pas nécessaire de tester non défini, car il est inclus dans la vérification (valeur == null). Vous pouvez également imiter le comportement C # en les ajoutant à String comme ceci:

String.IsNullOrEmpty = function (value) { ... }

Vous ne voulez pas le placer dans le prototype de Strings, car si l'instance de la classe String est nulle, l'erreur sera la suivante:

String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // could be set
myvar.IsNullOrEmpty(); // throws error

J'ai testé avec le tableau de valeurs suivant. En cas de doute, vous pouvez le parcourir en boucle pour tester vos fonctions.

// Helper items
var MyClass = function (b) { this.a = "Hello World!"; this.b = b; };
MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
var z;
var arr = [
// 0: Explanation for printing, 1: actual value
    ['undefined', undefined],
    ['(var) z', z],
    ['null', null],
    ['empty', ''],
    ['space', ' '],
    ['tab', '\t'],
    ['newline', '\n'],
    ['carriage return', '\r'],
    ['"\\r\\n"', '\r\n'],
    ['"\\n\\r"', '\n\r'],
    ['" \\t \\n "', ' \t \n '],
    ['" txt \\t test \\n"', ' txt \t test \n'],
    ['"txt"', "txt"],
    ['"undefined"', 'undefined'],
    ['"null"', 'null'],
    ['"0"', '0'],
    ['"1"', '1'],
    ['"1.5"', '1.5'],
    ['"1,5"', '1,5'], // valid number in some locales, not in js
    ['comma', ','],
    ['dot', '.'],
    ['".5"', '.5'],
    ['0', 0],
    ['0.0', 0.0],
    ['1', 1],
    ['1.5', 1.5],
    ['NaN', NaN],
    ['/\S/', /\S/],
    ['true', true],
    ['false', false],
    ['function, returns true', function () { return true; } ],
    ['function, returns false', function () { return false; } ],
    ['function, returns null', function () { return null; } ],
    ['function, returns string', function () { return "test"; } ],
    ['function, returns undefined', function () { } ],
    ['MyClass', MyClass],
    ['new MyClass', new MyClass()],
    ['empty object', {}],
    ['non-empty object', { a: "a", match: "bogus", test: "bogus"}],
    ['object with toString: string', { a: "a", match: "bogus", test: "bogus", toString: function () { return "test"; } }],
    ['object with toString: null', { a: "a", match: "bogus", test: "bogus", toString: function () { return null; } }]
];

Answer 24

pour vérifier si est exactement une chaîne vide:

if(val==="")...

pour vérifier s’il s’agit d’une chaîne vide OU d’un équivalent logique pour aucune valeur (null, undefined, 0, NaN, false, ...):

if(!val)...

Answer 25

En attendant, nous pouvons avoir une fonction qui vérifie tous les "vides" comme null, undefined, '', '', {}, [] . Je viens donc d'écrire ceci.

var isEmpty = function(data) {
    if(typeof(data) === 'object'){
        if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
            return true;
        }else if(!data){
            return true;
        }
        return false;
    }else if(typeof(data) === 'string'){
        if(!data.trim()){
            return true;
        }
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
    }else{
        return false;
    }
}

Cas d'utilisation et résultats.

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false

Answer 26

Il n'y a pas de méthode isEmpty () , vous devez vérifier le type et la longueur:

if (typeof test === 'string' && test.length === 0){
  ...

La vérification de type est nécessaire afin d'éviter les erreurs d'exécution lorsque test est indéfini ou null .

Answer 27

Ne supposez pas que la variable que vous cochez est une chaîne. Ne supposez pas que si cette variable a une longueur, c'est une chaîne.

Le problème est le suivant: réfléchissez bien à ce que votre application doit faire et peut accepter. Construisez quelque chose de robuste.

Si votre méthode / fonction ne doit traiter qu'une chaîne non vide, alors testez si l'argument est une chaîne non vide et ne faites pas de "ruse".

Comme exemple de quelque chose qui va exploser si vous suivez quelques conseils ici pas attentivement.

var getLastChar = function (str) {
 if (str.length > 0)
   return str.charAt(str.length - 1)
}

getLastChar('hello')
=> "o"

getLastChar([0,1,2,3])
=> TypeError: Object [object Array] has no method 'charAt'

Donc, je resterais avec

if (myVar === '')
  ...

Answer 28

Essayez ceci

str.value.length == 0

Answer 29

Vous pouvez facilement l'ajouter à l'objet Chaîne natif dans JavaScript et le réutiliser plusieurs fois ...
Quelque chose de simple comme le code ci-dessous peut faire le travail pour vous si vous voulez vérifier '' des chaînes vides:

String.prototype.isEmpty = String.prototype.isEmpty || function() {
  return !(!!this.length);
}

Sinon, si vous souhaitez vérifier à la fois '' chaîne vide et '' avec espace, vous pouvez le faire en ajoutant simplement trim () , quelque chose comme le code ci-dessous:

String.prototype.isEmpty = String.prototype.isEmpty || function() {
   return !(!!this.trim().length);
}

et vous pouvez l'appeler de cette façon:

''.isEmpty(); //return true
'alireza'.isEmpty(); //return false

Answer 30

function tell()
{
var pass = document.getElementById('pasword').value;
var plen = pass.length;

now you can check if your string is empty as like 
if(plen==0)
{
         alert('empty');
}
else
{
   alert('you entered something');
}
}


<input type='text' id='pasword' />

c’est aussi un moyen générique de vérifier si le champ est vide.