Comment vérifier Qu'il n'y a pas de chaîne vide dans JavaScript?

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 de l'espace blanc:

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

Tout ce qui précède sont bons, mais ce sera encore mieux. utiliser !! ( not ) opérateur.

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

ou utiliser le type de coulée:

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

font tous les deux la même fonction, type mouler la variable à booléen, où str est une variable.

Renvoie false pour null,undefined,0,000,"",false .

Renvoie true pour la chaîne "0" et espace " ".

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

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

la chose la plus proche que vous pouvez obtenir à str.Empty (avec la condition préalable que str est une chaîne de caractères) est:

if (!str.length) { ...

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

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

il n'y a rien qui représente une chaîne vide en JavaScript. Faites un contrôle contre length (si vous savez que le var sera toujours une chaîne de caractères) ou contre ""

, Essayez:

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

Je ne me soucierais pas trop de la méthode la plus efficace . Utilisez ce qui est le plus clair à votre intention. Pour moi, c'est habituellement strVar == "" .

EDIT: par commentaire de Constantin , si strVar pourraient finir contenant un entier de valeur 0, alors ce serait en effet l'un de ceux de l'intention de clarifier des situations.

fonction:

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

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

il couvre un grand nombre de cas comme {} , '' , null , undefined etc.

mais il renvoie toujours true pour Number type de types de données primitives Javascript comme _.isEmpty(10) ou _.isEmpty(Number.MAX_VALUE) les deux renvoie true .

vous pouvez aussi utiliser regexps:

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

vérifie si les chaînes sont vides ou remplies de blancs.

1. vérifier que var a; existe

2. couper le false spaces dans la valeur, puis tester pour emptiness

   "

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

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 beaucoup d'autres exemples sont disponibles. La meilleure méthode fonctionnelle pour y arriver, 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.

aussi, dans le cas où vous considérez une chaîne remplie de blancs comme"vide". Vous pouvez le tester avec ce Regex:

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

j'utilise habituellement quelque chose comme ça,

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

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

var y = ""151900920""; // 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(/^["151910920"]*$/)); 
}
...
""151910920"".isNull() // true

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

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

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

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

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

ignorant les chaînes d'espace, vous pouvez utiliser ceci pour vérifier null, vide et non défini:

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

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

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

Concise et il fonctionne pour des propriétés non définies, bien qu'il ne soit pas le plus lisible.

toutes ces réponses sont jolies.

mais je ne peux pas être sûr que la variable est une chaîne, ne contient pas seulement 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 jsfiddle .

j'utilise habituellement quelque chose comme:

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

j'ai fait quelques recherches ce qui se passe si vous passez une valeur non-string et non-empty/null à une fonction de testeur. Comme beaucoup le savent, (0 == "") est vrai dans javascript, mais puisque 0 est une valeur et non vide ou null, vous pouvez vouloir le tester.

les deux fonctions suivantes renvoient true uniquement pour les valeurs non définies, nulles, vides/espaces 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));
}

plus compliqué exemples existent, mais elles sont simples et donnent des résultats cohérents. Il n'est pas nécessaire de tester pour non défini, car il est inclus dans (valeur == null) check. Vous pouvez aussi imiter c # behaviour en les ajoutant à la chaîne comme ceci:

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

vous ne voulez pas le mettre dans les chaînes prototype, parce que si l'instance de la classe String est nulle, elle fera 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 faire une boucle à travers 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 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; } }]
];

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 no-value (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){
  ...

le contrôle de type est nécessaire pour éviter les erreurs d'exécution lorsque test est undefined ou null .

Essayez cette

   str.value.length == 0

en attendant, nous pouvons avoir une fonction qui vérifie tous les "vides" comme null, Non défini, ", ' ', {}, [] . Alors j'ai juste écrit ce.

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 des 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

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 une méthode générique permettant de vérifier si le champ est vide.

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

le truc est: pensez attentivement à 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 "truc".

comme exemple de quelque chose qui explosera si vous suivez ici quelques conseils pas prudent.

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 m'en tiendrais à

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

vous devriez toujours vérifier le type aussi, puisque JavaScript est un canard langage dactylographié, de sorte que vous ne pouvez pas savoir quand et comment les données ont changé au milieu du processus. Donc, voici la meilleure solution:

var str = "";
if (str === "") {
    //...
}