JavaScript'te boş / tanımsız / boş bir dizeyi nasıl kontrol edebilirim?

Bu soruyu gördüm , ancak JavaScript'e özgü bir örnek görmedim. string.EmptyJavaScript'te basit bir metin var mı , yoksa sadece kontrol etme vakası ""mı?

Sadece herhangi bir değer olup olmadığını kontrol etmek istiyorsanız,

if (strValue) {
    //do something
}

Eğer boş üzerinde boş bir dize için özel olarak kontrol etmek gerekiyorsa, ben karşılaştırarak kontrol düşünürdüm ""kullanarak, en iyi bahis operatörü (eğer, aslında, bir dize Size karşı karşılaştırarak konum olduğunu biliyoruz böylece).===

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

Bir dizenin boş, boş veya tanımsız olup olmadığını kontrol etmek için kullanıyorum:

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

Bir dizenin boş, boş veya tanımsız olup olmadığını kontrol etmek için kullanıyorum:

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

Bir dizenin boş olup olmadığını veya yalnızca beyaz boşluk içerip içermediğini kontrol etmek için:

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

Önceki tüm cevaplar iyi, ama bu daha da iyi olacak. !!( Değil ) operatörünü kullanın .

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

Veya tip döküm kullanın:

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

Her ikisi de aynı işlevi görür. Değişkeni Boolean olarak belirtin; burada strbir değişkentir.
Bu döner falseiçin null,undefined,0,000,"",false. "0" dizesi ve "" boşluk "için
geri döner true.

Alabileceğiniz en yakın şey str.Empty(str'nin bir String olduğu ön koşuluyla):

if (!str.length) { ...

Dize sadece bir sürü boş alan olmadığından emin olmanız gerekiyorsa (bunun form doğrulaması için olduğunu varsayıyorum) boşluklarda bir değişiklik yapmanız gerekir.

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

Kullanırım:

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

Sen kullanabilirsiniz lodash : _.isEmpty (değer).

Bu gibi durumlarda bir sürü kapsar {}, '', null, undefined, vb

Ama her zaman döndürür trueiçin Numbertürüne JavaScript ilkel veri türleri gibi _.isEmpty(10)veya _.isEmpty(Number.MAX_VALUE)her ikisi getiriler true.

İşlev:

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: JavaScript'te, sonra satır sonu kullanmayın return;

Deneyin:

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

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

JavaScript'te boş bir dizeyi temsil eden hiçbir şey yoktur. Ya karşı length(var değişkeninin her zaman bir dize olacağını biliyorsanız) ya da""

En verimli yöntem için fazla endişelenmezdim . Niyetinize en açık olanı kullanın. Benim için genellikle strVar == "".

Gelen yorum gereğince Constantin strVar bazı bir tamsayı 0 değerini içeren yeterli olabilir, eğer o gerçekten bu niyeti açıklayan durumlardan biri olacaktır.

Bir sürü cevap ve birçok farklı olasılık!

Hızlı ve basit bir uygulama için şüphesiz kazanan: if (!str.length) {...}

Ancak, diğer birçok örnek de mevcuttur. Bu konuda gitmek için en iyi fonksiyonel yöntem, ben öneririm:

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

Biraz fazla, biliyorum.

Ayrıca düzenli ifadelerle de gidebilirsiniz:

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

Boş veya boşlukla doldurulmuş dizeleri kontrol eder.

Verim

Seçilen 18 çözüm için macOS v10.13.6 (High Sierra) üzerinde testler yapıyorum . Çözümler, aşağıdaki kod parçasında sunulan biraz farklı (köşe kutusu giriş verileri için) çalışır.

Sonuçlar

• basit çözeltiler göre !str, ==, ===ve lengthbütün tarayıcılar için hızlı (A, B, C, G, I, J)
• çözümler normal ifadeye ( test, replace) dayalıdır ve charAttüm tarayıcılar için en yavaştır (H, L, M, P)
• en hızlı olarak işaretlenmiş çözümler yalnızca bir test çalıştırması için en hızlıdır - ancak birçok çalışmada 'hızlı' çözümler grubunda değişir

ayrıntılar

Aşağıdaki kod parçasında farklı giriş parametreleri kullanarak seçilen 18 yöntemin sonuçlarını karşılaştırıyorum

• "" "a" " "- boş dize, harfli dize ve boşluklu dize
• [] {} f- dizi, nesne ve işlev
• 0 1 NaN Infinity - sayılar
• true false - Boole
• null undefined

Test edilen yöntemlerin tümü tüm giriş durumlarını desteklemez.

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

Ve sonra tüm yöntemler str = ""için Chrome v78.0.0, Safari v13.0.4 ve Firefox v71.0.0 tarayıcıları için hız testi davası gerçekleştiriyorum - burada makinenizde testler yapabilirsiniz

1. var a;var olduğunu kontrol et

2. ayarlayabilmek false spacesdeğeri, daha sonra testemptiness

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

Ayrıca, boşlukla doldurulmuş bir dizeyi "boş" olarak değerlendirmeniz durumunda.

Bu normal ifade ile test edebilirsiniz:

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

Genellikle böyle bir şey kullanırım,

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

Ben bir dize null karakter olasılığını dikkate alır bir cevap fark etmedim. Örneğin, bir boş karakter dizemiz varsa:

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

Geçersizliğini test etmek için böyle bir şey yapılabilir:

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

Boş bir dize ve boş bir dize üzerinde çalışır ve tüm dizeler için erişilebilir. Ek olarak, diğer JavaScript boş veya boşluk karakterlerini içerecek şekilde genişletilebilir (örn. Aralıksız alan, bayt sırası işareti, satır / paragraf ayırıcı, vb.).

Bu arada null, undefined, '', '', {}, [] gibi tüm 'boşalmaları' kontrol eden bir fonksiyona sahip olabiliriz . Bu yüzden yazdım.

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

Vakaları ve sonuçları kullanın.

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

Şu andan itibaren, bir dizenin boş olup olmadığını kontrol etmek için string.empty gibi doğrudan bir yöntem yoktur. Ancak kodunuzda, aşağıdaki gibi boş bir dize için bir sarıcı denetimi kullanabilirsiniz:

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

}

Bunu kullanarak dizenin tanımsız veya boş olmadığından da emin olabilirsiniz. Unutmayın, tanımsız, boş ve boş üç farklı şeydir.

Bütün bu cevaplar güzel.

Ancak değişkenin bir dize olduğundan, yalnızca boşluk içermediğinden (bu benim için önemlidir) ve '0' (dize) içerebileceğinden emin olamıyorum.

Benim versiyonum:

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

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

Jsfiddle üzerinde örnek .

Burada iyi bir cevap görmedim (en azından benim için uygun bir cevap değil)

Bu yüzden kendime cevap vermeye karar verdim:

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

Tanımsız olup olmadığını kontrol etmeye başlamanız gerekir. Aksi takdirde yönteminiz patlayabilir ve daha sonra null değerine veya boş bir dizeye eşit olup olmadığını kontrol edebilirsiniz.

Sahip olamaz !! ya da sadece if(value)kontrol edersen0 bu size yanlış cevap (0 false) vermek için gidiyor.

Bununla birlikte, şöyle bir yöntemle sarın:

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

PS .: Türünü kontrol etmenize gerek yok , çünkü yönteme girmeden önce bile patlayacak ve fırlayacaktı

Birinin sadece boş değil, aynı zamanda boş dizeleri de algılaması gerekiyorsa, Goral'ın cevabına ekleyeceğim:

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

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

Bunu dene

str.value.length == 0

JavaScript'te yerel String nesnesine kolayca ekleyebilir ve tekrar tekrar kullanabilirsiniz ... Aşağıdaki kod gibi basit bir şey, boş dizeleri kontrol etmek isterseniz işi sizin için yapabilir :
''

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

Aksi takdirde, hem ''boş dizeyi hem de ' 'boşlukla kontrol etmek isterseniz, bunu trim()aşağıdaki kod gibi bir şey ekleyerek yapabilirsiniz :

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

ve bu şekilde diyebilirsiniz:

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

Bunu dene:

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

Bir dize olmayan ve boş olmayan / null değeri bir test işlevine geçirirseniz ne olacağı konusunda biraz araştırma yaptım. Birçok kişinin bildiği gibi, (0 == "") JavaScript'te doğrudur, ancak 0 bir değer olduğu ve boş veya boş olmadığı için, bunu test etmek isteyebilirsiniz.

Aşağıdaki iki işlev yalnızca tanımsız, boş, boş / boşluk değerleri için doğru, sayılar, Boole, nesneler, ifadeler vb. Gibi her şey için false değerini döndürür.

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

Daha karmaşık örnekler vardır, ancak bunlar basittir ve tutarlı sonuçlar verir. (Value == null) kontrolüne dahil edildiğinden, tanımsız olarak test edilmesine gerek yoktur. Ayrıca C # davranışını aşağıdaki gibi String'e ekleyerek taklit edebilirsiniz :

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

String sınıfı prototipine koymak istemezsiniz, çünkü String sınıfının örneği null olursa, hata verir:

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

Aşağıdaki değer dizisi ile test ettim. Şüphe duyuyorsanız, işlevlerinizi test etmek için bunu kullanabilirsiniz.

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

Tam olarak boş bir dize olup olmadığını kontrol etmek için:

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

Boş bir dize VEYA değersiz (null, undefined, 0, NaN, false, ...) için mantıksal bir eşdeğer olup olmadığını kontrol etmek için:

if(!val)...

Hiçbir isEmpty()yöntem yok , türü ve uzunluğu kontrol etmelisiniz:

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

Tip onay zaman çalışma zamanı hataları önlemek için gerekli olduğunu testolduğunu undefinedveya null.

Boşluk dizelerini yok sayarak, boş, boş ve tanımsız olup olmadığını kontrol etmek için bunu kullanabilirsiniz:

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

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

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

Özlüdür ve en okunabilir olmasa da, tanımsız özellikler için çalışır.