ฉันจะตรวจสอบสตริงว่าง / ไม่ได้กำหนด / null ใน JavaScript ได้อย่างไร

ฉันเห็นคำถามนี้แต่ฉันไม่เห็นตัวอย่างเฉพาะ JavaScript มีง่ายๆstring.Emptyใน JavaScript หรือเป็นเพียงการตรวจสอบ""หรือไม่

หากคุณเพียงต้องการตรวจสอบว่ามีค่าใด ๆ คุณสามารถทำได้

if (strValue) {
    //do something
}

หากคุณต้องการที่จะตรวจสอบเฉพาะสำหรับสตริงว่างมากกว่าโมฆะฉันคิดว่าการตรวจสอบกับ""เป็นทางออกที่ดีที่สุดของคุณโดยใช้ประกอบการ (เพื่อให้คุณรู้ว่ามันเป็นในความเป็นจริงสตริงคุณกำลังเปรียบเทียบกับ)===

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

สำหรับการตรวจสอบว่าสตริงว่างเปล่าเป็นโมฆะหรือไม่ได้กำหนดฉันใช้:

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

สำหรับการตรวจสอบว่าสตริงว่างเปล่าเป็นโมฆะหรือไม่ได้กำหนดฉันใช้:

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

สำหรับการตรวจสอบว่าสตริงว่างหรือมีเพียง white-space:

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

คำตอบก่อนหน้าทั้งหมดดี แต่นี่จะดีกว่า ใช้ตัวดำเนินการ!!( ไม่ใช่ )

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

หรือใช้การหล่อแบบ:

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

ทั้งสองทำหน้าที่เดียวกัน พิมพ์ตัวแปรไปที่บูลีนโดยที่strเป็นตัวแปร
ก็จะส่งกลับสำหรับfalse มันจะส่งกลับสำหรับสตริง "0" และช่องว่าง ""null,undefined,0,000,"",false
true

สิ่งที่ใกล้เคียงที่สุดที่คุณสามารถไปถึงstr.Empty(ด้วยเงื่อนไขที่ str คือสตริง) คือ:

if (!str.length) { ...

หากคุณต้องการตรวจสอบให้แน่ใจว่าสตริงไม่ได้เป็นเพียงช่องว่างขนาดใหญ่ (ฉันสมมติว่านี่เป็นเพียงการตรวจสอบความถูกต้องของฟอร์ม) คุณต้องทำการแทนที่ช่องว่าง

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

ฉันใช้:

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

คุณสามารถใช้lodash : _.isEmpty (ค่า)

มันครอบคลุมมากในกรณีเช่น{}, '', null, undefinedฯลฯ

แต่จะส่งคืนtrueสำหรับNumberชนิดของข้อมูลดั้งเดิมของJavaScriptเช่น_.isEmpty(10)หรือ_.isEmpty(Number.MAX_VALUE)ส่งคืนทั้งสองtrueอย่าง

ฟังก์ชั่น:

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 อย่าใช้ตัวแบ่งบรรทัดหลังจากreturn;

ลอง:

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

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

ไม่มีสิ่งใดที่แสดงถึงสตริงว่างใน JavaScript ตรวจสอบอย่างใดอย่างหนึ่งlength(ถ้าคุณรู้ว่า var จะเป็นสตริง) หรือต่อ""

ฉันจะไม่กังวลมากเกินไปเกี่ยวกับวิธีการที่มีประสิทธิภาพที่สุด ใช้สิ่งที่ชัดเจนที่สุดสำหรับความตั้งใจของคุณ strVar == ""สำหรับผมที่มักจะ

ตามความคิดเห็นจากConstantinถ้า strVar สามารถสรุปได้ว่ามีค่าจำนวนเต็ม 0 แล้วนั่นจะเป็นหนึ่งในสถานการณ์ที่ชัดเจนโดยเจตนา

คำตอบมากมายและมีความเป็นไปได้ต่าง ๆ มากมาย!

ไม่ต้องสงสัยเลยว่าการใช้งานอย่างรวดเร็วและง่ายดายผู้ชนะคือ: if (!str.length) {...}

อย่างไรก็ตามมีตัวอย่างให้เลือกมากมาย วิธีการทำงานที่ดีที่สุดที่จะไปเกี่ยวกับเรื่องนี้ฉันอยากจะแนะนำ:

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

ฉันรู้มากไปหน่อย

คุณสามารถใช้นิพจน์ทั่วไป:

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

ตรวจสอบสตริงที่ว่างเปล่าหรือเติมด้วยช่องว่าง

ประสิทธิภาพ

ฉันทำการทดสอบบนmacOS v10.13.6 (High Sierra) สำหรับโซลูชันที่เลือก 18 ข้อ โซลูชันทำงานแตกต่างกันเล็กน้อย (สำหรับข้อมูลอินพุตตัวพิมพ์มุม) ซึ่งแสดงในตัวอย่างด้านล่าง

สรุปผลการวิจัย

• โซลูชั่นที่ง่ายขึ้นอยู่กับ!str, ==, ===และlengthมีความรวดเร็วสำหรับเบราว์เซอร์ (A, B, C, G, I, J)
• วิธีการแก้ปัญหาขึ้นอยู่กับการแสดงออกปกติ ( test, replace) และcharAtช้าที่สุดสำหรับเบราว์เซอร์ทั้งหมด (H, L, M, P)
• การแก้ปัญหาที่ทำเครื่องหมายว่าเร็วที่สุดนั้นเร็วที่สุดสำหรับการทดสอบครั้งเดียวเท่านั้น แต่ในการทดสอบหลายครั้งมันจะเปลี่ยนแปลงภายในกลุ่มโซลูชัน 'รวดเร็ว'

รายละเอียด

ในตัวอย่างด้านล่างฉันเปรียบเทียบผลลัพธ์ของวิธีการที่เลือก 18 วิธีโดยใช้พารามิเตอร์อินพุตที่แตกต่างกัน

• "" "a" " "- สตริงว่างสตริงด้วยตัวอักษรและสตริงที่มีช่องว่าง
• [] {} f- อาร์เรย์วัตถุและฟังก์ชั่น
• 0 1 NaN Infinity - ตัวเลข
• true false - บูลีน
• null undefined

ไม่ใช่วิธีการทดสอบทั้งหมดที่รองรับกรณีอินพุตทั้งหมด

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

และสำหรับทุกวิธีที่ฉันใช้ทดสอบเคสstr = ""สำหรับเบราว์เซอร์ Chrome v78.0.0, Safari v13.0.4 และ Firefox v71.0.0 - คุณสามารถรันการทดสอบบนเครื่องของคุณได้ที่นี่

1. ตรวจสอบว่าvar a;มีอยู่

2. ตัดออกfalse spacesในค่าจากนั้นทดสอบemptiness

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

นอกจากนี้ในกรณีที่คุณพิจารณาสตริงที่เติมช่องว่างเป็น "ว่างเปล่า"

คุณสามารถทดสอบด้วยนิพจน์ทั่วไปนี้:

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

ฉันมักจะใช้สิ่งนี้

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

ฉันไม่ได้สังเกตเห็นคำตอบที่คำนึงถึงความเป็นไปได้ของตัวอักษร 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

เพื่อทดสอบความว่างเปล่าของมันเราสามารถทำสิ่งนี้:

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

มันทำงานบนสตริงที่เป็นโมฆะและในสตริงที่ว่างเปล่าและมันสามารถเข้าถึงได้สำหรับทุกสาย นอกจากนี้ยังสามารถขยายให้มีอักขระว่างเปล่าหรือตัวเว้นวรรค JavaScript อื่น ๆ (เช่นพื้นที่ว่าง, เครื่องหมายคำสั่งไบต์, ตัวคั่นบรรทัด / ย่อหน้า ฯลฯ )

ขณะที่เราสามารถมีฟังก์ชั่นที่ตรวจสอบทั้งหมด 'เปล่า' เหมือนโมฆะ undefined, '', '', {} [] ดังนั้นฉันเพิ่งเขียนสิ่งนี้

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

ใช้เคสและผลลัพธ์

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

ณ ตอนนี้ไม่มีวิธีโดยตรงเช่น string.empty เพื่อตรวจสอบว่าสตริงว่างเปล่าหรือไม่ แต่ในรหัสของคุณคุณสามารถใช้การตรวจสอบ wrapper สำหรับสตริงว่างเช่น:

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

}

การใช้สิ่งนี้คุณสามารถมั่นใจได้ว่าสตริงนั้นไม่ได้ถูกกำหนดหรือเป็นโมฆะ จำไว้ว่า undefined, null และ empty เป็นสามสิ่งที่แตกต่างกัน

คำตอบทั้งหมดเหล่านี้เป็นสิ่งที่ดี

แต่ฉันไม่แน่ใจว่าตัวแปรนั้นเป็นสตริงไม่ได้มีแค่ช่องว่าง (สิ่งนี้สำคัญสำหรับฉัน) และสามารถมี '0' (สตริง)

รุ่นของฉัน:

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

ฉันไม่เห็นคำตอบที่ดีที่นี่ (อย่างน้อยก็ไม่ใช่คำตอบที่เหมาะกับฉัน)

ดังนั้นฉันตัดสินใจที่จะตอบตัวเอง:

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

คุณต้องเริ่มตรวจสอบว่ามันไม่ได้กำหนด มิฉะนั้นวิธีการของคุณสามารถระเบิดและจากนั้นคุณสามารถตรวจสอบว่ามันเป็นโมฆะหรือเท่ากับสตริงที่ว่างเปล่า

คุณไม่มี !! หรือเพียงif(value)เพราะถ้าคุณตรวจสอบ0มันจะให้คำตอบที่ผิด (0 เป็นเท็จ)

ด้วยวิธีที่กล่าวมาห่อมันด้วยวิธีดังนี้:

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

ป.ล. : คุณไม่จำเป็นต้องตรวจสอบ typeofเพราะมันจะระเบิดและขว้างก่อนที่มันจะเข้าสู่วิธีการ

หากต้องการตรวจสอบไม่เพียง แต่ว่างเปล่า แต่ยังสตริงว่างฉันจะเพิ่มคำตอบของ Goral:

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

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

ลองสิ่งนี้

str.value.length == 0

คุณสามารถเพิ่มไปยังวัตถุStringดั้งเดิมในJavaScriptและนำมาใช้ซ้ำแล้วซ้ำอีก ...
สิ่งที่ง่ายเช่นรหัสด้านล่างสามารถทำงานให้คุณได้ถ้าคุณต้องการตรวจสอบ''สตริงว่าง:

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

มิฉะนั้นหากคุณต้องการตรวจสอบทั้ง''สตริงว่างและ' 'มีช่องว่างคุณสามารถทำได้โดยเพิ่มเพียงtrim()บางอย่างเช่นโค้ดด้านล่าง:

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

และคุณสามารถเรียกมันด้วยวิธีนี้:

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

ลองสิ่งนี้:

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

ฉันได้ทำการวิจัยบางอย่างเกี่ยวกับสิ่งที่เกิดขึ้นถ้าคุณส่งค่าที่ไม่ใช่สตริงและไม่ว่าง / ไม่มีค่าเป็นฟังก์ชันผู้ทดสอบ หลายคนรู้ว่า (0 == "") เป็นความจริงใน JavaScript แต่เนื่องจาก 0 เป็นค่าและไม่ว่างเปล่าหรือเป็นโมฆะคุณอาจต้องการทดสอบ

สองฟังก์ชันต่อไปนี้จะคืนค่าเป็นจริงเฉพาะสำหรับค่าที่ไม่ได้กำหนดค่าว่างค่าว่าง / ช่องว่างและค่าเท็จสำหรับทุกอย่างเช่นตัวเลขบูลีนวัตถุนิพจน์ ฯลฯ

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

มีตัวอย่างที่ซับซ้อนมากขึ้น แต่สิ่งเหล่านี้เรียบง่ายและให้ผลลัพธ์ที่สอดคล้องกัน ไม่จำเป็นต้องทดสอบสำหรับไม่ได้กำหนดเนื่องจากมันรวมอยู่ในการตรวจสอบ (ค่า == null) คุณอาจเลียนแบบพฤติกรรมC #โดยเพิ่มลงใน String ดังนี้:

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

คุณไม่ต้องการที่จะใส่มันไว้ในต้นแบบ Strings เพราะถ้าอินสแตนซ์ของ String-class เป็นโมฆะมันจะเกิดข้อผิดพลาด:

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

ฉันทดสอบกับอาร์เรย์ค่าต่อไปนี้ คุณสามารถวนซ้ำเพื่อทดสอบการทำงานของคุณหากมีข้อสงสัย

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

ในการตรวจสอบว่าเป็นสตริงว่างหรือไม่:

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

ในการตรวจสอบว่าเป็นสตริงว่างหรือเทียบเท่าเชิงตรรกะสำหรับไม่มีค่า (null, ไม่ได้กำหนด, 0, NaN, false, ... ):

if(!val)...

ไม่มีisEmpty()วิธีใดคุณต้องตรวจสอบประเภทและความยาว:

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

การตรวจสอบชนิดเป็นสิ่งจำเป็นในการสั่งซื้อเพื่อหลีกเลี่ยงข้อผิดพลาดเมื่อtestเป็นหรือundefinednull

ไม่สนใจสตริง whitespace คุณสามารถใช้สิ่งนี้เพื่อตรวจสอบค่าว่างเปล่าและไม่ได้กำหนด:

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

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

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

มันกระชับและใช้งานได้กับคุณสมบัติที่ไม่ได้กำหนดแม้ว่ามันจะไม่สามารถอ่านได้มากที่สุด