Bagaimana saya bisa memeriksa string kosong / tidak terdefinisi / null dalam JavaScript?

Saya melihat pertanyaan ini , tetapi saya tidak melihat contoh spesifik JavaScript. Apakah ada yang sederhana string.Emptytersedia di JavaScript, atau itu hanya kasus memeriksa ""?

Jika Anda hanya ingin memeriksa apakah ada nilai, Anda bisa melakukannya

if (strValue) {
    //do something
}

Jika Anda perlu memeriksa khusus untuk string kosong lebih null, saya akan berpikir memeriksa terhadap ""adalah taruhan terbaik Anda, menggunakan para ===Operator (sehingga Anda tahu bahwa itu adalah, pada kenyataannya, string Anda membandingkan terhadap).

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

Untuk memeriksa apakah string kosong, nol atau tidak terdefinisi, saya menggunakan:

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

Untuk memeriksa apakah string kosong, nol atau tidak terdefinisi, saya menggunakan:

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

Untuk memeriksa apakah string kosong atau hanya berisi ruang putih:

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

Semua jawaban sebelumnya baik, tetapi ini akan lebih baik. Gunakan operator !!( bukan tidak ).

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

Atau gunakan tipe casting:

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

Keduanya melakukan fungsi yang sama. Tipecast variabel ke Boolean, di mana strvariabel.
Ia kembali falseuntuk null,undefined,0,000,"",false.
Ini mengembalikan trueuntuk string "0" dan spasi putih "".

Hal terdekat yang bisa Anda dapatkan str.Empty(dengan prasyarat bahwa str adalah sebuah String) adalah:

if (!str.length) { ...

Jika Anda perlu memastikan bahwa string bukan hanya sekelompok ruang kosong (saya berasumsi ini untuk validasi formulir), Anda perlu melakukan penggantian pada spasi.

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

Saya menggunakan:

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

Anda dapat menggunakan lodash : _.isEmpty (nilai).

Ini mencakup banyak kasus seperti {}, '', null, undefined, dll

Tetapi selalu kembali trueuntuk Numberjenis tipe data primitif JavaScript seperti _.isEmpty(10)atau _.isEmpty(Number.MAX_VALUE)keduanya kembali true.

Fungsi:

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: Dalam JavaScript, jangan gunakan jeda baris setelah return;

Mencoba:

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

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

Tidak ada yang mewakili string kosong dalam JavaScript. Lakukan pengecekan terhadap salah length(jika Anda tahu bahwa var akan selalu berupa string) atau menentang""

Saya tidak akan terlalu khawatir tentang metode yang paling efisien . Gunakan apa yang paling jelas untuk niat Anda. Bagi saya itu biasanya strVar == "".

Sesuai komentar dari Constantin , jika strVar dapat bagaimana akhirnya mengandung nilai integer 0, maka itu memang akan menjadi salah satu situasi yang mengklarifikasi niat.

Banyak jawaban, dan banyak kemungkinan berbeda!

Tanpa ragu untuk implementasi cepat dan sederhana pemenangnya adalah: if (!str.length) {...}

Namun, karena banyak contoh lain tersedia. Metode fungsional terbaik untuk ini, saya sarankan:

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

Agak berlebihan, saya tahu.

Anda juga bisa menggunakan ekspresi reguler:

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

Memeriksa string yang kosong atau diisi dengan spasi putih.

Performa

Saya melakukan tes pada macOS v10.13.6 (High Sierra) untuk 18 solusi yang dipilih. Solusi berfungsi sedikit berbeda (untuk data masukan kasus sudut) yang disajikan dalam cuplikan di bawah ini.

Kesimpulan

• solusi sederhana berdasarkan !str, ==, ===dan lengthcepat untuk semua browser (A, B, C, G, I, J)
• solusi berdasarkan pada ekspresi reguler ( test, replace) dan charAtpaling lambat untuk semua browser (H, L, M, P)
• solusi yang ditandai sebagai tercepat adalah yang tercepat hanya untuk satu kali uji coba - tetapi dalam banyak langkah itu berubah di dalam grup solusi 'cepat'

Detail

Dalam cuplikan di bawah ini saya membandingkan hasil dari 18 metode yang dipilih dengan menggunakan parameter input yang berbeda

• "" "a" " "- string kosong, string dengan huruf dan string dengan spasi
• [] {} f- Array, objek dan fungsi
• 0 1 NaN Infinity - angka
• true false - Boolean
• null undefined

Tidak semua metode yang diuji mendukung semua kasus masukan.

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

Dan kemudian untuk semua metode, saya melakukan test case kecepatan str = ""untuk browser Chrome v78.0.0, Safari v13.0.4, dan Firefox v71.0.0 - Anda dapat menjalankan tes pada mesin Anda di sini

1. periksa yang var a;ada

2. potong false spacesnilainya, lalu ujiemptiness

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

Juga, jika Anda menganggap string yang diisi spasi sebagai "kosong".

Anda dapat mengujinya dengan ekspresi reguler ini:

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

Saya biasanya menggunakan sesuatu seperti ini,

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

Saya belum melihat jawaban yang memperhitungkan kemungkinan karakter nol dalam sebuah string. Misalnya, jika kita memiliki string karakter nol:

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

Untuk menguji nullnessnya, seseorang dapat melakukan sesuatu seperti ini:

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

Ini bekerja pada string nol, dan pada string kosong dan dapat diakses untuk semua string. Selain itu, dapat diperluas untuk berisi JavaScript kosong atau karakter spasi lainnya (yaitu ruang nonbreaking, tanda urutan byte, pemisah baris / paragraf, dll.).

Sementara itu kita dapat memiliki satu fungsi yang memeriksa semua 'kosong' seperti null, undefined, '', '', {}, [] . Jadi saya hanya menulis ini.

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

Gunakan kasing dan hasil.

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

Sampai sekarang tidak ada metode langsung seperti string.empty untuk memeriksa apakah string kosong atau tidak. Tetapi dalam kode Anda, Anda dapat menggunakan pembungkus untuk memeriksa string kosong seperti:

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

}

Menggunakan ini, Anda juga dapat memastikan bahwa string tidak terdefinisi atau nol juga. Ingat, tidak terdefinisi, nol, dan kosong adalah tiga hal yang berbeda.

Semua jawaban ini bagus.

Tetapi saya tidak dapat memastikan bahwa variabel adalah string, tidak hanya berisi spasi (ini penting bagi saya), dan dapat berisi '0' (string).

Versi saya:

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

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

Contoh di jsfiddle .

Saya tidak melihat jawaban yang bagus di sini (setidaknya bukan jawaban yang cocok untuk saya)

Jadi saya memutuskan untuk menjawab sendiri:

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

Anda harus mulai memeriksa apakah itu tidak terdefinisi. Kalau tidak, metode Anda bisa meledak, dan kemudian Anda dapat memeriksa apakah itu sama dengan nol atau sama dengan string kosong.

Anda tidak dapat memiliki !! atau hanya if(value)karena jika Anda memeriksa 0itu akan memberi Anda jawaban yang salah (0 salah).

Dengan demikian, bungkus dengan metode seperti:

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

PS: Anda tidak perlu memeriksa typeof , karena itu akan meledak dan melempar bahkan sebelum memasuki metode

Jika seseorang perlu mendeteksi tidak hanya string kosong tetapi juga kosong, saya akan menambahkan jawaban Goral:

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

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

Coba ini

str.value.length == 0

Anda dapat dengan mudah menambahkannya ke objek String asli di JavaScript dan menggunakannya kembali berulang-ulang ...
Sesuatu yang sederhana seperti kode di bawah ini dapat melakukan pekerjaan untuk Anda jika Anda ingin memeriksa ''string kosong:

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

Kalau tidak, jika Anda ingin memeriksa ''string kosong dan ' 'dengan spasi, Anda dapat melakukannya dengan hanya menambahkan trim(), sesuatu seperti kode di bawah ini:

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

dan Anda bisa menyebutnya seperti ini:

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

Coba ini:

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

Saya melakukan riset tentang apa yang terjadi jika Anda melewatkan nilai non-string dan non-kosong / nol ke fungsi tester. Seperti yang diketahui banyak orang, (0 == "") benar dalam JavaScript, tetapi karena 0 adalah nilai dan bukan kosong atau nol, Anda mungkin ingin mengujinya.

Dua fungsi berikut ini mengembalikan true hanya untuk nilai yang tidak terdefinisi, null, kosong / spasi putih dan false untuk yang lainnya, seperti angka, Boolean, objek, ekspresi, dll.

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

Contoh yang lebih rumit ada, tetapi ini sederhana dan memberikan hasil yang konsisten. Tidak perlu menguji undefined, karena itu termasuk dalam (nilai == null) cek. Anda juga dapat meniru perilaku C # dengan menambahkannya ke String seperti ini:

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

Anda tidak ingin memasukkannya ke dalam prototipe Strings, karena jika instance dari kelas-String adalah nol, itu akan kesalahan:

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

Saya diuji dengan array nilai berikut. Anda dapat memutarnya untuk menguji fungsi Anda jika ragu.

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

Untuk memeriksa apakah itu benar-benar string kosong:

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

Untuk memeriksa apakah itu string kosong ATAU setara logis untuk nilai-tidak (nol, tidak terdefinisi, 0, NaN, false, ...):

if(!val)...

Tidak ada isEmpty()metode, Anda harus memeriksa jenis dan panjangnya:

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

Jenis pemeriksaan yang diperlukan untuk menghindari kesalahan runtime saat testini undefinedatau null.

Mengabaikan string spasi putih, Anda bisa menggunakan ini untuk memeriksa null, kosong, dan tidak terdefinisi:

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

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

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

Ini ringkas dan berfungsi untuk properti yang tidak terdefinisi, meskipun bukan yang paling mudah dibaca.