Jak sprawdzić pusty łańcuch w JavaScript?

Do sprawdzania czy łańcuch jest pusty, null lub undefined używam:

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

Do sprawdzania czy łańcuch jest pusty, null lub undefined używam:

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

Do sprawdzania, czy łańcuch jest pusty lub zawiera tylko białą spację:

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

Wszystkie powyższe są dobre, ale to będzie jeszcze lepsze. użycie !!(Nie Nie ) operator.

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

Lub użyć odlewu typu:

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

Obie wykonują tę samą funkcję, typuj zmienną na boolean, gdzie str jest zmienną.
Zwraca false dla null,undefined,0,000,"",false.
Zwraca true Dla ciągu znaków " 0 "i białych znaków"".

Jeśli chcesz się upewnić, że ciąg znaków nie jest tylko zbiorem pustych spacji (zakładam, że jest to Walidacja formularza), musisz wykonać zastąpienie spacji.

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

Najbliższą rzeczą, do której możesz się dostać str.Empty (z warunkiem, że str jest ciągiem znaków) jest:

if (!str.length) { ...

Używam:

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

Nie ma nic reprezentującego pusty łańcuch w JavaScript. Wykonaj sprawdzenie przeciwko length (jeśli wiesz, że var zawsze będzie ciągiem znaków) lub przeciwko ""

Try:

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

Nie martwiłbym się zbytnio o najbardziej efektywną metodę. Użyj tego, co jest najbardziej jasne dla Twojej intencji. Dla mnie to zazwyczaj strVar == "".

EDIT: per comment from Constantin , if strVar could some how end up containing an integer 0 value, then that would really be one of those intention-clearing situations.

Funkcja:

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

Możesz użyć lodash : _.isEmpty (wartość).

Obejmuje wiele spraw, takich jak {}, '', null, undefined itd.

Ale zawsze zwraca true dla Number typu JavaScript prymitywne typy danych jak _.isEmpty(10) lub _.isEmpty(Number.MAX_VALUE) oba zwracają true.

Możesz również użyć wyrażeń regularnych:

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

Sprawdza, czy ciągi znaków są puste lub wypełnione białymi znakami.

1. sprawdź czy var a; Istnieją

2. Trim out false spaces in the value, then test for emptiness

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

Wiele odpowiedzi i wiele różnych możliwości!

Bez wątpienia dla szybkiej i prostej realizacji zwycięzcą jest: if (!str.length) {...}

Jednak, jak wiele innych przykładów jest dostępnych. Najlepsza funkcjonalna metoda, aby to zrobić, sugerowałbym:

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

Również, jeśli uznasz, że wypełniony białymi znakami łańcuch jest "pusty". Możesz go przetestować za pomocą tego wyrażenia regularnego:

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

Zwykle używam czegoś takiego,

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

Nie zauważyłem odpowiedzi, która uwzględnia możliwość wystąpienia znaków null w łańcuchu. Na przykład, jeśli mamy łańcuch znaków null:

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

Aby sprawdzić jego nieważność można zrobić coś takiego:

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

Działa na łańcuchu null oraz na pustym łańcuchu i jest dostępny dla wszystkich łańcuchów. Ponadto może być rozszerzony o inne puste lub białe znaki JavaScript (np. niełamliwe spacje, znak kolejności bajtów, separator linii/akapitu, itd.).

Jeśli trzeba wykryć nie tylko puste, ale i puste ciągi, dodam do Gorala odpowiedź:

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

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

Używam kombinacji, najszybsze kontrole są pierwsze.

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

Ignorując ciągi znaków spacji, możesz użyć tego do sprawdzenia null, empty i undefined:

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

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

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

Zwięzły i działa dla niezdefiniowanych właściwości, chociaż nie jest najbardziej czytelny.

Wszystkie te odpowiedzi są miłe.

Ale nie mogę być pewien, że zmienna jest ciągiem znaków, nie zawiera tylko spacji (jest to dla mnie ważne) i może zawierać '0' (string).

Moja Wersja:

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

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

Próbka na jsfiddle .

Zwykle używam czegoś w stylu:

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

Zrobiłem kilka badań, co się stanie, jeśli przekażesz wartość non-string i niepustą / null do funkcji testera. Jak wielu wie, (0 == "") jest prawdą w javascript, ale ponieważ 0 jest wartością, a nie pustą lub null, możesz chcieć ją przetestować.

Następujące dwie funkcje zwracają true tylko dla wartości undefined, null, empty / whitespace i false dla wszystkich innych, takich jak liczby, logika logiczna, obiekty, wyrażenia itp.

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

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

Nie chcesz umieszczać tego w prototypie Strings, ponieważ jeśli instancja klasy String jest null, spowoduje to błąd:

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

Testowałem z poniższą tablicą wartości. Możesz go zapętlić, aby przetestować swoje funkcje, jeśli masz wątpliwości.

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

Aby sprawdzić, czy jest dokładnie pusty łańcuch:

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

Aby sprawdzić, czy jest to pusty łańcuch lub logiczny odpowiednik Dla no-value (null, undefined, 0, Nan, false,...):

if(!val)...

Nie ma metody isEmpty(), musisz sprawdzić typ i długość:

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

Sprawdzanie typu jest konieczne, aby uniknąć błędów podczas pracy, gdy test jest undefined lub null.

Spróbuj tego

   str.value.length == 0

Tymczasem możemy mieć jedną funkcję, która sprawdza wszystkie "pustki" jak null, undefined, ", ' ', {}, []. Więc właśnie to napisałem.

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

Przypadki użycia i wyniki.

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' />

Jest to również ogólny sposób sprawdzenia, czy pole jest puste.

Nie zakładaj, że zmienna, którą sprawdzasz, jest łańcuchem znaków. Nie zakładaj, że jeśli ten var ma długość, to jest ciągiem znaków.

Rzecz w tym, że: zastanów się dokładnie, co Twoja aplikacja musi zrobić i może zaakceptować. Zbuduj coś solidnego.

Jeśli twoja metoda / funkcja powinna przetwarzać tylko niepusty łańcuch znaków, sprawdź, czy argument jest niepustym łańcuchem znaków i nie rób jakiegoś 'triku'.

Jako przykład czegoś, co wybuchnie, jeśli zastosujesz się do niektórych porad tutaj nie ostrożnie.

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'

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

Należy zawsze sprawdzać również Typ, ponieważ JavaScript jest językiem pisanym kaczką, więc możesz nie wiedzieć, kiedy i jak dane zmieniły się w środku procesu. Więc, tutaj jest lepsze rozwiązanie:

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