Làm cách nào tôi có thể kiểm tra chuỗi rỗng / không xác định / null trong JavaScript?

Tôi đã thấy câu hỏi này , nhưng tôi không thấy một ví dụ cụ thể về JavaScript. Có một đơn giản string.Emptycó sẵn trong JavaScript hay chỉ là một trường hợp kiểm tra ""?

Nếu bạn chỉ muốn kiểm tra xem có giá trị nào không, bạn có thể làm

if (strValue) {
    //do something
}

Nếu bạn cần phải kiểm tra đặc biệt cho một chuỗi rỗng trên null, tôi sẽ nghĩ kiểm tra chống lại ""là đặt cược tốt nhất của bạn, sử dụng các ===nhà điều hành (để bạn biết rằng nó là, trên thực tế, một chuỗi bạn so sánh chống lại).

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

Để kiểm tra xem một chuỗi có trống không, null hoặc không xác định tôi sử dụng:

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

Để kiểm tra xem một chuỗi có trống, null hoặc không xác định tôi sử dụng:

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

Để kiểm tra xem một chuỗi có trống hay chỉ chứa khoảng trắng:

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

Tất cả các câu trả lời trước là tốt, nhưng điều này sẽ còn tốt hơn. Sử dụng toán tử !!( không phải ).

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

Hoặc sử dụng kiểu đúc:

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

Cả hai đều làm cùng một chức năng. Kiểu chữ biến thành Boolean, trong đó strlà một biến.
Nó trả về falsecho null,undefined,0,000,"",false.
Nó trả về truechuỗi "0" và khoảng trắng "".

Điều gần nhất bạn có thể nhận được str.Empty(với điều kiện tiên quyết là str là Chuỗi) là:

if (!str.length) { ...

Nếu bạn cần đảm bảo rằng chuỗi không chỉ là một loạt các khoảng trống (tôi giả sử đây là để xác thực mẫu), bạn cần phải thay thế trên các khoảng trắng.

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

Tôi sử dụng:

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

Bạn có thể sử dụng lodash : _.isEmpty (giá trị).

Nó bao gồm rất nhiều trường hợp như thế {}, '', null, undefinedvv

Nhưng nó luôn luôn trả truecho Numberloại Javascript kiểu dữ liệu nguyên thủy như _.isEmpty(10)hoặc _.isEmpty(Number.MAX_VALUE)cả lợi nhuận true.

Chức năng:

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: Trong JavaScript, không sử dụng ngắt dòng sau return;

Thử:

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

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

Không có gì đại diện cho một chuỗi rỗng trong JavaScript. Thực hiện kiểm tra đối với một trong hai length(nếu bạn biết rằng var sẽ luôn là một chuỗi) hoặc chống lại""

Tôi sẽ không lo lắng quá nhiều về phương pháp hiệu quả nhất . Sử dụng những gì rõ ràng nhất với ý định của bạn. Đối với tôi đó là thường xuyên strVar == "".

Theo nhận xét từ Constantin , nếu strVar có thể kết thúc bằng cách chứa giá trị số nguyên 0 thì đó thực sự sẽ là một trong những tình huống làm rõ ý định đó.

Rất nhiều câu trả lời, và rất nhiều khả năng khác nhau!

Không nghi ngờ gì để thực hiện nhanh chóng và đơn giản, người chiến thắng là: if (!str.length) {...}

Tuy nhiên, như nhiều ví dụ khác có sẵn. Phương pháp chức năng tốt nhất để thực hiện điều này, tôi muốn đề xuất:

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

Một chút quá mức, tôi biết.

Bạn cũng có thể đi với các biểu thức thông thường:

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

Kiểm tra các chuỗi trống hoặc chứa đầy khoảng trắng.

Hiệu suất

Tôi thực hiện các thử nghiệm trên macOS v10.13.6 (High Sierra) cho 18 giải pháp được chọn. Các giải pháp hoạt động hơi khác nhau (đối với dữ liệu nhập trường hợp góc) được trình bày trong đoạn trích dưới đây.

Kết luận

• các giải pháp đơn giản dựa trên !str, ==, ===và lengthđang nhanh chóng cho tất cả các trình duyệt (A, B, C, G, I, J)
• các giải pháp dựa trên biểu thức chính quy ( test, replace) và charAtchậm nhất cho tất cả các trình duyệt (H, L, M, P)
• các giải pháp được đánh dấu là nhanh nhất chỉ nhanh nhất cho một lần chạy thử - nhưng trong nhiều lần chạy, nó thay đổi trong nhóm giải pháp 'nhanh'

Chi tiết

Trong đoạn trích dưới đây, tôi so sánh kết quả của 18 phương thức được chọn bằng cách sử dụng các tham số đầu vào khác nhau

• "" "a" " "- chuỗi rỗng, chuỗi có chữ và chuỗi có khoảng trắng
• [] {} f- mảng, đối tượng và chức năng
• 0 1 NaN Infinity - số
• true false - Boolean
• null undefined

Không phải tất cả các phương pháp được thử nghiệm đều hỗ trợ tất cả các trường hợp đầu vào.

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

Và sau đó, đối với tất cả các phương pháp tôi thực hiện trường hợp kiểm tra tốc độ str = ""cho trình duyệt Chrome v78.0.0, Safari v13.0.4 và Firefox v71.0.0 - bạn có thể chạy thử nghiệm trên máy của mình tại đây

1. kiểm tra xem có var a;tồn tại không

2. cắt ra false spacestrong giá trị, sau đó kiểm traemptiness

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

Ngoài ra, trong trường hợp bạn coi một chuỗi chứa khoảng trắng là "trống".

Bạn có thể kiểm tra nó với biểu thức chính quy này:

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

Tôi thường sử dụng một cái gì đó như thế này,

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

Tôi đã không nhận thấy một câu trả lời có tính đến khả năng của các ký tự null trong một chuỗi. Ví dụ: nếu chúng ta có chuỗi ký tự 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

Để kiểm tra tính vô hiệu của nó, người ta có thể làm một cái gì đó như thế này:

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

Nó hoạt động trên một chuỗi rỗng và trên một chuỗi trống và nó có thể truy cập được cho tất cả các chuỗi. Ngoài ra, nó có thể được mở rộng để chứa các ký tự trống hoặc khoảng trắng JavaScript khác (nghĩa là không gian không phá vỡ, dấu thứ tự byte, dấu tách dòng / đoạn, v.v.).

Trong khi đó, chúng ta có thể có một chức năng kiểm tra tất cả các 'trống' như null, không xác định, '', '', {}, [] . Vì vậy, tôi chỉ viết này.

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

Trường hợp sử dụng và kết quả.

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

Cho đến bây giờ không có phương thức trực tiếp nào như string.empty để kiểm tra xem một chuỗi có trống hay không. Nhưng trong mã của bạn, bạn có thể sử dụng kiểm tra trình bao bọc cho một chuỗi trống như:

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

}

Sử dụng điều này, bạn cũng có thể đảm bảo rằng chuỗi không được xác định hoặc null quá. Hãy nhớ rằng, không xác định, null và trống là ba điều khác nhau.

Tất cả những câu trả lời là tốt đẹp.

Nhưng tôi không thể chắc chắn rằng biến đó là một chuỗi, không chỉ chứa khoảng trắng (điều này rất quan trọng đối với tôi) và có thể chứa '0' (chuỗi).

Phiên bản của tôi:

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

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

Mẫu trên jsfiddle .

Tôi không thấy câu trả lời hay ở đây (ít nhất không phải là câu trả lời phù hợp với tôi)

Vì vậy, tôi quyết định tự trả lời:

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

Bạn cần bắt đầu kiểm tra nếu nó không được xác định. Mặt khác, phương thức của bạn có thể phát nổ, và sau đó bạn có thể kiểm tra xem nó bằng null hay bằng một chuỗi rỗng.

Bạn không thể có !! hoặc chỉ if(value)vì nếu bạn kiểm tra 0nó sẽ cung cấp cho bạn một câu trả lời sai (0 là sai).

Như đã nói, hãy gói nó theo một phương thức như:

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

Tái bút: Bạn không cần kiểm tra typeof , vì nó sẽ phát nổ và ném ngay cả trước khi nó đi vào phương thức

Nếu một người cần phát hiện không chỉ các chuỗi trống mà cả các chuỗi trống, tôi sẽ thêm vào câu trả lời của Goral:

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

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

Thử cái này

str.value.length == 0

Bạn có thể dễ dàng thêm nó vào đối tượng Chuỗi gốc trong JavaScript và sử dụng lại nhiều lần ...
Một cái gì đó đơn giản như mã dưới đây có thể thực hiện công việc cho bạn nếu bạn muốn kiểm tra ''các chuỗi trống:

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

Mặt khác, nếu bạn muốn kiểm tra cả ''chuỗi trống và ' 'với khoảng trắng , bạn có thể làm điều đó bằng cách chỉ cần thêm trim(), một cái gì đó giống như mã dưới đây:

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

và bạn có thể gọi nó theo cách này:

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

Thử cái này:

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

Tôi đã thực hiện một số nghiên cứu về những gì xảy ra nếu bạn chuyển một giá trị không phải là chuỗi và không rỗng / null cho hàm kiểm tra. Như nhiều người biết, (0 == "") là đúng trong JavaScript, nhưng vì 0 là một giá trị và không trống hoặc null, nên bạn có thể muốn kiểm tra nó.

Hai hàm sau chỉ trả về true cho các giá trị không xác định, null, rỗng / khoảng trắng và false cho mọi thứ khác, chẳng hạn như số, Boolean, đối tượng, biểu thức, v.v.

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

Các ví dụ phức tạp hơn tồn tại, nhưng đây là những đơn giản và cho kết quả phù hợp. Không cần kiểm tra không xác định, vì nó được bao gồm trong kiểm tra (value == null). Bạn cũng có thể bắt chước hành vi C # bằng cách thêm chúng vào Chuỗi như thế này:

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

Bạn không muốn đặt nó trong nguyên mẫu Chuỗi, vì nếu thể hiện của lớp String là null, nó sẽ báo lỗi:

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

Tôi đã thử nghiệm với mảng giá trị sau. Bạn có thể lặp nó qua để kiểm tra các chức năng của mình nếu nghi ngờ.

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

Để kiểm tra xem nó có chính xác là một chuỗi rỗng không:

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

Để kiểm tra xem đó có phải là một chuỗi rỗng HOẶC tương đương logic cho không có giá trị (null, không xác định, 0, NaN, false, ...):

if(!val)...

Không có isEmpty()phương pháp, bạn phải kiểm tra loại và độ dài:

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

Vui lòng cung loại là cần thiết để tránh các lỗi runtime khi testlà undefinedhay null.

Bỏ qua các chuỗi khoảng trắng, bạn có thể sử dụng chuỗi này để kiểm tra null, trống và không xác định:

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

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

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

Nó ngắn gọn và nó hoạt động cho các thuộc tính không xác định, mặc dù nó không phải là dễ đọc nhất.