Widziałem To pytanie, ale nie Zobacz podobny przykład JavaScript. Czy w JavaScript znajduje się prosta string.Empty lub jest to tylko przypadek sprawdzania ""?

3338
casademora 30 wrzesień 2008, 21:17

30 odpowiedzi

Najlepsza odpowiedź

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

if (strValue) {
    //do something
}

Jeśli chcesz sprawdzić specjalnie dla pustego łańcucha null, pomyślałbym sprawdzenie przeciwko "" jest najlepszym betem, używając Operator === (tak, że wiesz, że jest w rzeczywistości ciągiem porównującym).

if (strValue === "") {
    //...
}
3908
bdukes 2 czerwiec 2018, 00:29

Aby sprawdzić, czy ciąg jest pusty, pusty lub niezdefiniowany, używam:

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

Aby sprawdzić, czy ciąg jest pusty, pusty lub niezdefiniowany, używam:

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

Aby sprawdzić, czy ciąg jest pusty lub zawiera tylko spacje:

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};
1203
Scott Harwell 13 maj 2014, 14:00

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

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

Lub użyj odlewania typu:

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

Oba wykonują tę samą funkcję. Zmieniaj zmienną do Boolean, gdzie str jest zmienną.
Powraca false dla null,undefined,0,000,"",false.
Powraca true dla ciągów "0" i białe znaki "".

379
Penny Liu 11 listopad 2020, 06:25

Najbliższą rzeczą, jaką możesz dostać się do str.Empty (Wraz z warstwą, że STR jest ciągiem) to:

if (!str.length) { ...
112
Kick Buttowski 31 sierpień 2018, 16:08

Jeśli chcesz upewnić się, że ciąg nie jest tylko grupą pustych przestrzeni (zakładam, że jest to walidację formularza), musisz wykonać zastąpienie na przestrzeni.

if(str.replace(/\s/g,"") == ""){
}
106
Sugendran 30 wrzesień 2008, 23:08

Ignorując sznurki whitespace, można użyć tego do sprawdzenia za pomocą NULL, Puste i niezdefiniowane:

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 niezdefiniowanych właściwości, choć nie jest najbardziej czytelny.

7
Peter Mortensen 8 marzec 2020, 23:47

Używam kombinacji, a najszybsze czeki są najpierw.

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);
}
7
Peter Mortensen 8 marzec 2020, 23:49

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
70
Peter Mortensen 8 marzec 2020, 23:39

Możesz użyć Lodash: _. Wartość (wartość).

Obejmuje wiele przypadków, takich jak {}, '', null, undefined itp

Ale zawsze zwraca true dla Number typ Typy danych prymitywnych JavaScript jak _.isEmpty(10) lub _.isEmpty(Number.MAX_VALUE) Oba zwroty true.

49
Peter Mortensen 9 marzec 2020, 00:17

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 przerwy linii po return;

42
T.Todua 7 październik 2020, 00:57
var s; // undefined
var s = ""; // ""
s.length // 0

Nic nie reprezentuje pustego sznurka w JavaScript. Wykonaj czek przeciwko length (jeśli wiesz, że var zawsze będzie ciągiem) lub przeciwko {x1}}

38
cllpse 30 wrzesień 2008, 17:42

Próbować:

if (str && str.trim().length) {  
    //...
}
38
afuzzyllama 9 styczeń 2013, 03:15

Nie martwiłbym się zbytnio o najbardziej wydajnej metody . Użyj tego, co jest najbardziej jasne do twojej intencji. Dla mnie zazwyczaj strVar == "".

Zgodnie z komentarzem z Constantin, jeśli Strvar mógłby jakiś skończył się zawierającą wartość liczbę całkowitą 0, to byłoby rzeczywiście jeden tych sytuacji wyjaśniających intencji.

31
Peter Mortensen 8 marzec 2020, 23:39

Możesz także iść z wyrażeniami regularnymi:

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

Sprawdza ciągów, które są puste lub wypełnione białe znaki.

22
Peter Mortensen 8 marzec 2020, 23:39

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

Bez wątpienia na szybką i prostą implementację zwycięzcą jest: if (!str.length) {...}

Jednakże istnieje wiele innych przykładów. Najlepszą metodą funkcjonalną do tego, 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;
    }
}

Nie wiem trochę nadmierne.

21
Praveen M P 3 listopad 2020, 12:10

Również na wypadek, gdybyś rozważył wygląd wypełniony przez białe znaki jako "puste".

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

!/\S/.test(string); // Returns true if blank.
17
Peter Mortensen 8 marzec 2020, 23:55

Zwykle używam czegoś takiego,

if (!str.length) {
    // Do something
}
16
Peter Mortensen 8 marzec 2020, 23:58

Jeśli trzeba wykryć nie tylko puste, ale także puste struny, dodam do odpowiedzi Goral:

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

function isBlank(s){
    return isEmpty(s.trim());    
}
13
Josef.B 1 październik 2014, 06:55

Nie zauważyłem odpowiedzi, która uwzględnia możliwość zerowych znaków 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 przetestować swoją niewolniczą, można zrobić coś takiego:

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

Działa na łańcuchu NULL, a na pustym ciągu i jest dostępny dla wszystkich strun. Ponadto można go rozszerzyć, aby zawierał inne postacie javascript pustych lub białych znaków (I.E. Space. Space, znak bajtowy, separator linii / akapitu itp.).

11
Bikush 31 lipiec 2012, 14:05

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

Używaj przypadków i wyników.

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
11
Imran Ahmad 12 marzec 2018, 08:48

Na razie nie ma bezpośredniej metody, takiej jak string.empty, aby sprawdzić, czy ciąg jest pusty, czy nie. Ale w swoim kodzie możesz użyć opakowania sprawdzić dla pustego sznurka:

// 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 ciąg nie jest niezdefiniowany lub null. Pamiętaj, niezdefiniowany, null i puste są trzy różne rzeczy.

11
Harshit Agarwal 3 wrzesień 2019, 08:25

Nie widziałem tutaj dobrej odpowiedzi (przynajmniej nie odpowiedź, która dla mnie pasuje)

Więc zdecydowałem się odpowiedzieć:

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

Musisz zacząć sprawdzać, czy jest niezdefiniowany. W przeciwnym razie Twoja metoda może eksplodować, a następnie możesz sprawdzić, czy równa się null lub jest równa pustym łańcuchowi.

Nie możesz mieć !! lub tylko if(value), ponieważ sprawdzisz 0, daje Ci fałszywa odpowiedź (0 jest fałszywa).

Z tym powiedzianym, owinąć go w sposób, jak:

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

PS.: Nie musisz sprawdzać typef , ponieważ eksploduje i rzuci, zanim wejdzie

11
Peter Mortensen 9 marzec 2020, 00:21

Wszystkie te odpowiedzi są ładne.

Ale nie mogę być pewien, że zmienna jest sznurkiem, nie zawiera tylko przestrzeni (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.

10
Peter Mortensen 8 marzec 2020, 23:52

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

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

Aby sprawdzić, czy jest to pusty ciąg lub logiczny odpowiednik bez wartości (Null, Undefined, 0, NAN, FAŁSZ, ...):

if(!val)...
10
Peter Mortensen 9 marzec 2020, 00:16

Spróbuj tego:

export const isEmpty = string => (!string || !string.length);
9
CroMagnon 14 czerwiec 2019, 11:01

Zrobiłem kilka badań nad tym, co się dzieje, jeśli przekazujesz wartość nieustanną i nieustanną / null do funkcji testera. Tyle wie, (0 == "") jest prawdą w JavaScript, ale ponieważ 0 to wartość, a nie pusta lub null, możesz go przetestować.

Następujące dwie funkcje zwracają się true tylko dla niezdefiniowanych, wartości pustych / białych wartości i false na wszystko inne, takie jak liczby, boolean, obiekty, wyrażenia itp.

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

Istnieje bardziej skomplikowane przykłady, ale są to proste wyniki. Nie ma potrzeby testowania niezdefiniowanego, ponieważ jest to uwzględnione (Value == Null)). Możesz także naśladować C # zachowanie, dodając je do łańcucha:

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

Nie chcesz umieścić go w ramach prototypów ciągów, ponieważ jeśli instancja klasa string jest null, błędów:

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

Testowałem z następującym tablicą wartości. W razie wątpliwości można przetestować, aby przetestować swoje funkcje.

// 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; } }]
];
9
Peter Mortensen 8 marzec 2020, 23:55

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

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

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

8
Agustí Sánchez 4 listopad 2016, 22:28

Spróbuj tego

str.value.length == 0
8
Neuron 8 styczeń 2019, 04:39

Możesz łatwo dodać go do rodzimych Ciąg obiekt w JavaScript i ponownie wykorzystać go przez ...
Coś prostego jak poniżej kodu może wykonać zadanie, jeśli chcesz sprawdzić '' puste struny:

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

W przeciwnym razie, jeśli chcesz sprawdzić pusty ciąg

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

I możesz nazwać to w ten sposób:

''.isEmpty(); //return true
'alireza'.isEmpty(); //return false
8
Alireza 19 styczeń 2019, 06:19

Wydajność

Wykonuję testy na MacOS V10.13.6 (High Sierra) dla 18 wybranych rozwiązań. Rozwiązania działa nieznacznie inaczej (dla danych wejściowych Corner-Case), które zostały przedstawione w fragmence poniżej.

Wnioski

  • Proste rozwiązania oparte na !str, ==, === i length i length są szybkie dla wszystkich przeglądarek (A, B, C, G, I, J)
  • Rozwiązania oparte na wyrażeniu regularnym (test, replace) i charAt 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 przebiegu zmienia się wewnątrz "szybkiej grupy rozwiązań

Enter image description here

Detale

W poniższym fragmencie porównuję wyniki wybranych 18 metod za pomocą różnych parametrów wejściowych

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

Nie wszystkie testowane metody obsługują wszystkie przypadki wejściowe.

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 testu prędkości str = "" dla przeglądarek Chrome V78.0.0, Safari V13.0.4 i Firefox V71.0.0 - Możesz uruchomić testy na komputerze Tutaj

Enter image description here

39
Kamil Kiełczewski 9 marzec 2020, 06:03