Jak mogę sprawdzić pusty / niezdefiniowany / zerowy ciąg w JavaScript?

Widziałem to pytanie , ale nie widziałem konkretnego przykładu w JavaScript. Czy string.EmptyJavaScript jest dostępny w prosty sposób , czy jest to tylko sprawdzenie ""?

Jeśli chcesz tylko sprawdzić, czy jest jakaś wartość, możesz to zrobić

if (strValue) {
    //do something
}

Jeśli trzeba sprawdzić specjalnie dla pusty ciąg nad null, to myślę sprawdzaniu ""jest najlepszy, korzystając z ===operatora (tak, że wiesz, że to jest w rzeczywistości ciąg jesteś porównując przeciw).

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

Do sprawdzenia, czy łańcuch jest pusty, pusty lub niezdefiniowany, używam:

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

Do sprawdzenia, czy łańcuch jest pusty, zerowy lub niezdefiniowany, używam:

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

Aby sprawdzić, czy ciąg znaków jest pusty lub zawiera tylko białe znaki:

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

Wszystkie poprzednie odpowiedzi są dobre, ale będzie jeszcze lepiej. Użyj operatora !!( nie ).

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

Lub użyj rzutowania typu:

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

Oba wykonują tę samą funkcję. Wpisz zmienną do Boolean, gdzie strjest zmienną.
Wraca falseza null,undefined,0,000,"",false.
Zwraca trueciąg „0” i białe znaki „”.

Najbliższą rzeczą, jaką można uzyskać str.Empty(pod warunkiem, że str jest ciągiem znaków) jest:

if (!str.length) { ...

Jeśli musisz się upewnić, że ciąg nie jest tylko garstką pustych spacji (zakładam, że jest to do sprawdzania poprawności formularza), musisz wykonać zamianę na spacje.

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

Używam:

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

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

Obejmuje ona wiele takich przypadkach {}, '', null, undefined, itd.

Ale ona zawsze wraca truedo Numberrodzaju JavaScript prymitywne typy danych , jak _.isEmpty(10)i _.isEmpty(Number.MAX_VALUE)obu zwrotów true.

Funkcjonować:

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: W JavaScript nie używaj podziału linii po return;

Próbować:

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

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

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

Nie martwiłbym się zbytnio najbardziej wydajną metodą. Użyj tego, co jest najbardziej jasne dla twojej intencji. Dla mnie to zwyklestrVar == "" .

Zgodnie z komentarzem Constantina , jeśli strVar mógłby w jakiś sposób zawierać wartość całkowitą 0, to rzeczywiście byłaby to jedna z tych sytuacji wyjaśniających zamiary.

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

Bez wątpienia zwycięzcą jest szybkie i proste wdrożenie: if (!str.length) {...}

Jednak dostępnych jest wiele innych przykładów. Najlepsza funkcjonalna metoda na to, sugeruję:

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

To trochę przesada, wiem.

Możesz także użyć wyrażeń regularnych:

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

Sprawdza ciągi znaków, które są puste lub wypełnione białymi spacjami.

1. sprawdź, czy var a;istnieją

2. przyciąć false spaces wartość, a następnie sprawdźemptiness

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

Wydajność

Testy przeprowadzam na macOS 10.13.6 (High Sierra) dla 18 wybranych rozwiązań. Rozwiązania działają nieco inaczej (w przypadku danych wejściowych z narożników), co zostało przedstawione w poniższym fragmencie.

Wnioski

• Rozwiązania oparte na prostych !str, ==, ===ilength jest szybki dla przeglądarki (A, B, C, G, I, J)
• rozwiązania oparte na wyrażeniu regularnym ( test, replace) icharAt są najwolniejsze dla wszystkich przeglądarek (H, L, M, P)
• rozwiązania oznaczone jako najszybsze były najszybsze tylko dla jednego przebiegu testowego - ale w wielu przebiegach zmienia się w grupie „szybkich” rozwiązań

Detale

W poniższym fragmencie porównuję wyniki wybranych 18 metod przy użyciu różnych parametrów wejściowych

• "" "a" " "- pusty ciąg, ciąg z literą i ciąg ze spacją
• [] {} f- tablica, obiekt i funkcja
• 0 1 NaN Infinity - liczby
• true false - Boolean
• null undefined

Nie wszystkie przetestowane metody obsługują wszystkie przypadki wprowadzania danych.

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

A następnie dla wszystkich metod wykonuję przypadek testowy prędkości str = ""dla przeglądarek Chrome, Safari v13.0.4 v78.0.0 i Firefox v71.0.0 - można uruchomić testy na komputerze tutaj

Ponadto w przypadku, gdy uważasz ciąg wypełniony białymi znakami za „pusty”.

Możesz to przetestować za pomocą tego wyrażenia regularnego:

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

Zwykle używam czegoś takiego,

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

Nie zauważyłem odpowiedzi, która uwzględnia możliwość wystąpienia pustych znaków w ciągu. Na przykład, jeśli mamy ciąg znaków o wartości zerowej:

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 przetestować jego nieważność, można zrobić coś takiego:

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

Działa na łańcuch zerowy i na pusty łańcuch i jest dostępny dla wszystkich łańcuchów. Ponadto można go rozszerzyć, aby zawierał inne znaki JavaScript puste lub spacje (tj. Spację nierozdzielającą, znak kolejności bajtów, separator wierszy / akapitów itp.).

Tymczasem możemy mieć jedną funkcję, która sprawdza wszystkie „ puste ”, takie jak null, undefined, „”, „”, {}, [] . 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;
    }
}

Zastosuj przypadki 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

W tej chwili nie ma bezpośredniej metody, takiej jak string.empty, aby sprawdzić, czy łańcuch jest pusty, czy nie. Ale w kodzie możesz użyć kontroli opakowania dla pustego ciągu, takiego jak:

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

}

Korzystając z tego, możesz również upewnić się, że łańcuch nie jest niezdefiniowany lub również zerowy. Pamiętaj, niezdefiniowane, puste i puste to trzy różne rzeczy.

Wszystkie te odpowiedzi są miłe.

Ale nie mogę być pewien, że zmienna jest ciągiem, nie zawiera tylko spacji (jest to dla mnie ważne) i może zawierać „0” (ciąg).

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 .

Nie widziałem tutaj dobrej odpowiedzi (a przynajmniej takiej, która nie pasuje do mnie)

Postanowiłem więc odpowiedzieć sobie:

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

Musisz zacząć sprawdzać, czy jest niezdefiniowany. W przeciwnym razie twoja metoda może wybuchnąć, a następnie możesz sprawdzić, czy jest równa null lub jest równa pustemu ciągowi.

Nie możesz mieć !! lub tylko if(value)dlatego, że jeśli sprawdzisz 0, da ci fałszywą odpowiedź (0 to fałsz).

Powiedziawszy to, zawiń to w metodę taką jak:

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

PS .: Nie musisz sprawdzać typeof , ponieważ wybuchłby i rzuciłby jeszcze zanim wejdzie do metody

Jeśli trzeba wykryć nie tylko puste, ale i puste ciągi, dodam do odpowiedzi Górala:

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

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

Spróbuj tego

str.value.length == 0

Możesz łatwo dodać go do natywnego obiektu String w JavaScript i używać go w kółko ...
Coś prostego, takiego jak poniższy kod, może wykonać zadanie, jeśli chcesz sprawdzić ''puste ciągi:

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

W przeciwnym razie, jeśli chcesz sprawdzić zarówno ''pusty ciąg znaków, jak i ' 'spację, możesz to zrobić, dodając trim()coś w rodzaju kodu poniżej:

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

i możesz to tak nazwać:

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

Spróbuj tego:

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

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

Poniższe dwie funkcje zwracają wartość true tylko dla wartości niezdefiniowanych, pustych, pustych / białych i wartość false dla wszystkich innych elementów, takich jak liczby, wartości logiczne, obiekty, wyrażenia itp.

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

Istnieją bardziej skomplikowane przykłady, ale są one proste i dają spójne wyniki. Nie ma potrzeby testowania pod kątem niezdefiniowanej wartości, ponieważ jest ona uwzględniona w sprawdzaniu (wartość == null). Możesz także naśladować zachowanie C # , dodając je do ciągu w następujący sposób:

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

Nie chcesz umieszczać go w prototypie ciągów, ponieważ jeśli wystąpienie klasy String ma wartość NULL, wystąpi 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 sprawdzić swoje funkcje w razie 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 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; } }]
];

Aby sprawdzić, czy jest to dokładnie pusty ciąg:

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

Aby sprawdzić, czy jest to pusty ciąg LUB logiczny odpowiednik braku wartości (null, undefined, 0, NaN, false, ...):

if(!val)...

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

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

Sprawdzanie typu jest potrzebne, aby uniknąć błędów w czasie wykonywania, gdy testjest undefinedlub null.

Ignorując ciągi białych znaków, możesz użyć tego do sprawdzenia pustych, pustych i niezdefiniowanych:

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

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

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

Jest zwięzły i działa dla nieokreślonych właściwości, chociaż nie jest najbardziej czytelny.