Comment puis-je rechercher une chaîne vide / non définie / nulle en JavaScript?

J'ai vu cette question , mais je n'ai pas vu d'exemple spécifique à JavaScript. Existe-t-il un simple string.Emptydisponible en JavaScript, ou s'agit-il simplement d'une vérification ""?

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

if (strValue) {
    //do something
}

Si vous devez vérifier spécifiquement une chaîne vide par rapport à null, je pense que la vérification contre ""est votre meilleur pari, en utilisant l' ===opérateur (afin que vous sachiez qu'il s'agit en fait d'une chaîne que vous comparez).

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

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 blancs:

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

Toutes les réponses précédentes sont bonnes, mais ce sera encore mieux. Utilisez l' opérateur !!( pas non ).

if(!!str){
    // Some code here
}

Ou utilisez le casting de type:

if(Boolean(str)){
    // Code here
}

Les deux remplissent la même fonction. Typecast la variable en booléen, où strest une variable.
Il revient falsepour null,undefined,0,000,"",false.
Il renvoie la truechaîne "0" et les espaces "".

La chose la plus proche à laquelle vous pouvez accéder str.Empty(avec la condition préalable que str est une chaîne) est:

if (!str.length) { ...

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

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

J'utilise:

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

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

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

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

Mais elle retourne toujours truepour le Numbertype de JavaScript types de données primitives comme _.isEmpty(10)ou les _.isEmpty(Number.MAX_VALUE)deux déclarations true.

Essayer:

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

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

PS: En JavaScript, n'utilisez pas de saut de ligne après return;

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

Il n'y a rien qui représente une chaîne vide en JavaScript. Faites une vérification contre length(si vous savez que la var sera toujours une chaîne) ou contre""

Je ne m'inquiéterais pas trop de la méthode la plus efficace . Utilisez ce qui est le plus clair pour votre intention. Pour moi, c'est généralementstrVar == "" .

Selon le commentaire de Constantin , si strVar pouvait finir par contenir une valeur entière 0, ce serait en effet l'une de ces situations de clarification de l'intention.

Performance

J'effectue des tests sur macOS v10.13.6 (High Sierra) pour 18 solutions choisies. Les solutions fonctionnent légèrement différemment (pour les données d'entrée de cas d'angle), ce qui a été présenté dans l'extrait ci-dessous.

Conclusions

• les solutions simples basées sur !str, ==, ===etlength sont rapides pour tous les navigateurs (A, B, C, G, I, J)
• les solutions basées sur l'expression régulière ( test, replace) etcharAt sont les plus lentes pour tous les navigateurs (H, L, M, P)
• les solutions marquées comme les plus rapides n'étaient les plus rapides que pour un essai - mais dans de nombreux essais, elles changent dans le groupe de solutions «rapides»

Détails

Dans l'extrait ci-dessous, je compare les résultats des 18 méthodes choisies en utilisant différents paramètres d'entrée

• "" "a" " "- chaîne vide, chaîne avec lettre et chaîne avec espace
• [] {} f- tableau, objet et fonction
• 0 1 NaN Infinity - Nombres
• true false - booléen
• null undefined

Toutes les méthodes testées ne prennent pas en charge tous les cas d'entrée.

function A(str) {
  let r=1;
  if (!str)
    r=0;
  return r;
}

function B(str) {
  let r=1;
  if (str == "")
    r=0;
  return r;
}

function C(str) {
  let r=1;
  if (str === "")
    r=0;
  return r;
}

function D(str) {
  let r=1;
  if(!str || 0 === str.length)
    r=0;
  return r;
}

function E(str) {
  let r=1;
  if(!str || /^\s*$/.test(str))
    r=0;
  return r;
}

function F(str) {
  let r=1;
  if(!Boolean(str))
    r=0;
  return r;
}

function G(str) {
  let r=1;
  if(! ((typeof str != 'undefined') && str) )
    r=0;
  return r;
}

function H(str) {
  let r=1;
  if(!/\S/.test(str))
    r=0;
  return r;
}

function I(str) {
  let r=1;
  if (!str.length)
    r=0;
  return r;
}

function J(str) {
  let r=1;
  if(str.length <= 0)
    r=0;
  return r;
}

function K(str) {
  let r=1;
  if(str.length === 0 || !str.trim())
    r=0;
  return r;
}

function L(str) {
  let r=1;
  if ( str.replace(/\s/g,"") == "")
    r=0;
  return r;
}

function M(str) {
  let r=1;
  if((/^\s*$/).test(str))
    r=0;
  return r;
}


function N(str) {
  let r=1;
  if(!str || !str.trim().length)
    r=0;
  return r;
}

function O(str) {
  let r=1;
  if(!str || !str.trim())
    r=0;
  return r;
}

function P(str) {
  let r=1;
  if(!str.charAt(0))
    r=0;
  return r;
}

function Q(str) {
  let r=1;
  if(!str || (str.trim()==''))
    r=0;
  return r;
}

function R(str) {
  let r=1;
  if (typeof str == 'undefined' ||
      !str ||
      str.length === 0 ||
      str === "" ||
      !/[^\s]/.test(str) ||
      /^\s*$/.test(str) ||
      str.replace(/\s/g,"") === "")

    r=0;
  return r;
}




// --- TEST ---

console.log(                  '   ""  "a"  " " [] {} 0 1 NaN Infinity f true false null undefined ');
let log1 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}     ${f(null)}    ${f(undefined)}`);
let log2 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}`);
let log3 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}`);

log1('A', A);
log1('B', B);
log1('C', C);
log1('D', D);
log1('E', E);
log1('F', F);
log1('G', G);
log1('H', H);

log2('I', I);
log2('J', J);

log3('K', K);
log3('L', L);
log3('M', M);
log3('N', N);
log3('O', O);
log3('P', P);
log3('Q', Q);
log3('R', R);

Et puis pour toutes les méthodes str = "", j'effectue un test de vitesse pour les navigateurs Chrome v78.0.0, Safari v13.0.4 et Firefox v71.0.0 - vous pouvez exécuter des tests sur votre machine ici

Beaucoup de réponses et beaucoup de possibilités différentes!

Sans aucun doute pour une mise en œuvre simple et rapide, le gagnant est: if (!str.length) {...}

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

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.

Vous pouvez également utiliser des expressions régulières:

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

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

1. regarde ça var a; existent

2. rogner false spacesla valeur, puis tester pouremptiness

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

De plus, si vous considérez une chaîne remplie d'espaces comme "vide".

Vous pouvez le tester avec cette expression régulière:

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

J'utilise habituellement quelque chose comme ça,

if (!str.length) {
    // Do something
}

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 nullité, on pourrait faire quelque chose comme ceci:

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

Il fonctionne sur une chaîne nulle et sur une chaîne vide et il est accessible à toutes les chaînes. En outre, il pourrait être développé pour contenir d'autres caractères JavaScript vides ou blancs (c'est-à-dire un espace insécable, une marque d'ordre des octets, un séparateur de ligne / paragraphe, etc.).

Pendant ce temps, 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

Pour l'instant, il n'y a pas de méthode directe comme string.empty pour vérifier si une chaîne est vide ou non. Mais dans votre code, vous pouvez utiliser une vérification de wrapper pour une chaîne vide comme:

// considering the variable in which your string is saved is named str.

if (str && str.length>0) { 

  // Your code here which you want to run if the string is not empty.

}

En utilisant cela, vous pouvez également vous assurer que la chaîne n'est pas non plus définie ou nulle également. Rappelez-vous que non défini, nul et vide sont trois choses différentes.

Toutes ces réponses sont agréables.

Mais je ne peux pas être sûr que la variable est une chaîne, ne contient pas que des espaces (c'est important pour moi) et 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

Échantillon sur jsfiddle .

Je n'ai pas vu de bonne réponse ici (du moins pas une réponse qui me convient)

J'ai donc décidé de me répondre:

value === undefined || value === null || value === "";

Vous devez commencer à vérifier s'il n'est pas défini. Sinon, votre méthode peut exploser, puis vous pouvez vérifier si elle est égale à null ou est égale à une chaîne vide.

Vous ne pouvez pas avoir !! ou seulement if(value)parce que si vous cochez, 0cela va vous donner une fausse réponse (0 est faux).

Cela dit, enveloppez-le dans une méthode comme:

public static isEmpty(value: any): boolean { return value === undefined || value === null || value === ""; }

PS: Vous n'avez pas besoin de vérifier le typeof , car il exploserait et se lancerait même avant d'entrer dans la méthode

Si l'on a besoin de détecter non seulement des chaînes vides mais aussi vides, j'ajouterai à la réponse de Goral:

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

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

Essaye ça

str.value.length == 0

Vous pouvez facilement l'ajouter à l' objet String natif en JavaScript et le réutiliser encore et encore ...
Quelque chose de simple comme le code ci-dessous peut faire le travail pour vous si vous souhaitez vérifier ''les chaînes vides:

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

Sinon, si vous souhaitez vérifier à la fois la ''chaîne vide et l' ' '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

Essaye ça:

export const isEmpty = string => (!string || !string.length);

J'ai fait des recherches sur ce qui se passe si vous passez une valeur non chaîne et non vide / nulle à une fonction de testeur. Comme beaucoup le savent, (0 == "") est vrai en JavaScript, mais comme 0 est une valeur et non vide ou nulle, vous voudrez peut-être la tester.

Les deux fonctions suivantes renvoient true uniquement pour les valeurs non définies, nulles, vides / blancs et false 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 compliqués existent, mais ils sont simples et donnent des résultats cohérents. Il n'est pas nécessaire de tester undefined, 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 mettre dans le prototype Strings, car si l'instance de la classe String est nulle, cela produira une erreur:

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. Vous pouvez le parcourir pour tester vos fonctions en cas de doute.

// 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 JavaScript
    ['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; } }]
];

Pour vérifier s'il s'agit exactement d'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)...

Il n'y a pas de isEmpty()méthode, 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 testest undefinedou null.

En ignorant les chaînes d'espaces blancs, vous pouvez utiliser ceci 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

Il est concis et fonctionne pour les propriétés non définies, bien qu'il ne soit pas le plus lisible.