มีฟังก์ชั่นจาวาสคริปต์สากลที่ตรวจสอบว่าตัวแปรมีค่าและทำให้แน่ใจว่าไม่ใช่undefinedหรือnullไม่? ฉันได้รับรหัสนี้ แต่ไม่แน่ใจว่าครอบคลุมทุกกรณีหรือไม่:

function isEmpty(val){
    return (val === undefined || val == null || val.length <= 0) ? true : false;
}

คุณสามารถตรวจสอบว่าตัวแปรมีtruthyค่าหรือไม่ นั่นหมายความว่า

if( value ) {
}

จะมีการประเมินเพื่อtrueถ้าvalueเป็นไม่ได้ :

• โมฆะ
• ไม่ได้กำหนด
• น่าน
• สตริงว่าง ("")
• 0
• เท็จ

รายการด้านบนแสดงถึงfalsyค่าที่เป็นไปได้ทั้งหมดใน ECMA- / Javascript ค้นหาได้ในสเปคที่ToBooleanส่วน

นอกจากนี้หากคุณไม่ทราบว่ามีตัวแปรอยู่หรือไม่ (นั่นหมายความว่าหากมีการประกาศ ) คุณควรตรวจสอบกับtypeofผู้ปฏิบัติงาน ตัวอย่างเช่น

if( typeof foo !== 'undefined' ) {
    // foo could get resolved and it's defined
}

หากคุณมั่นใจได้ว่ามีการประกาศตัวแปรอย่างน้อยคุณควรตรวจสอบโดยตรงว่ามีtruthyค่าดังที่แสดงด้านบน

อ่านเพิ่มเติม: http://typeofnan.blogspot.com/2011/01/typeof-is-fast.html

วิธีการ verbose เพื่อตรวจสอบว่าค่าไม่ได้กำหนดหรือเป็นโมฆะ:

return value === undefined || value === null;

คุณสามารถใช้==โอเปอเรเตอร์ได้ แต่สิ่งนี้คาดว่าจะรู้กฎทั้งหมด :

return value == null; // also returns true if value is undefined

function isEmpty(value){
  return (value == null || value.length === 0);
}

สิ่งนี้จะกลับมาจริง

undefined  // Because undefined == null

null

[]

""

และฟังก์ชั่นอาร์กิวเมนต์เป็นศูนย์เนื่องจากฟังก์ชั่นlengthคือจำนวนของพารามิเตอร์ที่ประกาศใช้

หากไม่ต้องการหมวดหมู่หลังคุณอาจต้องการตรวจสอบสตริงว่าง

function isEmpty(value){
  return (value == null || value === '');
}

นี่คือการตรวจสอบที่ปลอดภัยที่สุดและฉันไม่ได้เห็นมันโพสต์ที่นี่เหมือนกับที่:

if (typeof value !== 'undefined' && value) {
    //deal with value'
};

มันจะครอบคลุมกรณีที่คุ้มค่าก็ไม่เคยกำหนดไว้และยังมีของเหล่านี้:

• โมฆะ
• ไม่ได้กำหนด (ค่าไม่ได้กำหนดไม่เหมือนกับพารามิเตอร์ที่ไม่เคยกำหนด)
• 0
• "" (สตริงว่าง)
• เท็จ
• น่าน

_{แก้ไข: เปลี่ยนเป็นความเท่าเทียมที่เข้มงวด (! ==) เพราะเป็นบรรทัดฐานในตอนนี้;)}

คุณอาจพบว่าฟังก์ชั่นต่อไปนี้มีประโยชน์:

function typeOf(obj) {
  return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}

หรือใน ES7 (แสดงความคิดเห็นหากการปรับปรุงเพิ่มเติม)

function typeOf(obj) {
  const { toString } = Object.prototype;
  const stringified = obj::toString();
  const type = stringified.split(' ')[1].slice(0, -1);

  return type.toLowerCase();
}

ผล:

typeOf(); //undefined
typeOf(null); //null
typeOf(NaN); //number
typeOf(5); //number
typeOf({}); //object
typeOf([]); //array
typeOf(''); //string
typeOf(function () {}); //function
typeOf(/a/) //regexp
typeOf(new Date()) //date
typeOf(new WeakMap()) //weakmap
typeOf(new Map()) //map

"โปรดทราบว่าตัวดำเนินการเชื่อมโยง (: :) ไม่ได้เป็นส่วนหนึ่งของ ES2016 (ES7) หรือมาตรฐาน ECMAScript รุ่นที่ใหม่กว่าทั้งหมดในปัจจุบันขณะนี้เป็นข้อเสนอขั้นที่ 0 (ฟางแมน) สำหรับการแนะนำให้รู้จักกับภาษา" - Simon Kjellberg ผู้เขียนต้องการเพิ่มการสนับสนุนของเขาสำหรับข้อเสนอที่สวยงามนี้เพื่อรับเสด็จขึ้นสู่สวรรค์

คำตอบแรกที่มีการให้คะแนนที่ดีที่สุดนั้นผิด หากค่าไม่ได้กำหนดจะมีข้อยกเว้นในเบราว์เซอร์ที่ทันสมัย คุณต้องใช้:

if (typeof(value) !== "undefined" && value)

หรือ

if (typeof value  !== "undefined" && value)

ตรวจสอบสภาพนี้

if (!!foo) {
    //foo is defined
}

คือทั้งหมดที่คุณต้องการ

! ตรวจสอบสตริงว่าง (""), โมฆะ, ไม่ได้กำหนด, เท็จและหมายเลข 0 และ NaN บอกว่าถ้าสตริงว่างเปล่าvar name = ""แล้วผลตอบแทนconsole.log(!name)true

function isEmpty(val){
  return !val;
}

ฟังก์ชั่นนี้จะกลับจริงถ้าValเป็นที่ว่างเปล่าโมฆะ undefined เท็จจำนวน 0 หรือน่าน

หรือ

ตามโดเมนปัญหาของคุณได้คุณก็สามารถใช้เหมือนหรือ!val!!val

ทางออกที่ฉันชอบมาก:

เรามากำหนดว่าตัวแปรว่างคือnullหรือundefinedหรือถ้ามันมีความยาวมันเป็นศูนย์หรือถ้ามันเป็นวัตถุมันไม่มีกุญแจ:

function isEmpty (value) {
  return (
    // null or undefined
    (value == null) ||

    // has length and it's zero
    (value.hasOwnProperty('length') && value.length === 0) ||

    // is an Object and has no keys
    (value.constructor === Object && Object.keys(value).length === 0)
  )
}

ผลตอบแทน:

• จริง: undefined , null, "", [],{}
• เท็จ true , false, 1, 0, -1, "foo", [1, 2, 3],{ foo: 1 }

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

function isEmpty(value){
    return (typeof value === "undefined" || value === null);
}

นี้คือสมมติ0, ""และวัตถุ (แม้วัตถุที่ว่างเปล่าและอาเรย์) ที่ถูกต้อง "คุณค่า"

หากคุณต้องการจาวาสคริปต์ธรรมดาให้ลอง:

  /**
   * Checks if `value` is empty. Arrays, strings, or `arguments` objects with a
   * length of `0` and objects with no own enumerable properties are considered
   * "empty".
   *
   * @static
   * @memberOf _
   * @category Objects
   * @param {Array|Object|string} value The value to inspect.
   * @returns {boolean} Returns `true` if the `value` is empty, else `false`.
   * @example
   *
   * _.isEmpty([1, 2, 3]);
   * // => false
   *
   * _.isEmpty([]);
   * // => true
   *
   * _.isEmpty({});
   * // => true
   *
   * _.isEmpty('');
   * // => true
   */

function isEmpty(value) {
    if (!value) {
      return true;
    }
    if (isArray(value) || isString(value)) {
      return !value.length;
    }
    for (var key in value) {
      if (hasOwnProperty.call(value, key)) {
        return false;
      }
    }
    return true;
  }

มิฉะนั้นหากคุณใช้เครื่องหมายขีดล่างหรือ lodash แล้วให้ลอง:

_.isEmpty(value)

นี่คือของฉัน - ส่งคืนจริงถ้าค่าเป็นโมฆะไม่ได้กำหนด ฯลฯ หรือว่างเปล่า (เช่นมีช่องว่างเท่านั้น):

function stringIsEmpty(value) {

    return value ? value.trim().length == 0 : true;

}

return val || 'Handle empty variable'

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

const res = val || 'default value'

หากตัวแปรไม่ได้รับการประกาศคุณจะไม่สามารถทดสอบการไม่ได้กำหนดโดยใช้ฟังก์ชันได้เนื่องจากคุณจะได้รับข้อผิดพลาด

if (foo) {}
function (bar) {}(foo)

ทั้งสองจะสร้างข้อผิดพลาดหาก foo ยังไม่ได้ประกาศ

หากคุณต้องการทดสอบว่ามีการประกาศตัวแปรหรือไม่คุณสามารถใช้

typeof foo != "undefined"

ถ้าคุณต้องการทดสอบว่ามีการประกาศ foo หรือไม่และมีค่าที่คุณสามารถใช้ได้

if (typeof foo != "undefined" && foo) {
    //code here
}

เพื่อตรวจสอบค่าเริ่มต้น

function typeOfVar (obj) {
      return {}.toString.call(obj).split(' ')[1].slice(0, -1).toLowerCase();
}
function isVariableHaveDefaltVal(variable) {
    if ( typeof(variable) === 'string' ) {  // number, boolean, string, object 
        console.log(' Any data Between single/double Quotes is treated as String ');        
        return (variable.trim().length === 0) ? true : false;
    }else if ( typeof(variable) === 'boolean' ) {
      console.log('boolean value with default value \'false\'');
        return (variable === false) ? true : false;
    }else if ( typeof(variable) === 'undefined' ) {
        console.log('EX: var a; variable is created, but has the default value of undefined.'); 
        return true;
    }else if ( typeof(variable) === 'number' ) { 
        console.log('number : '+variable);
        return (variable === 0 ) ? true : false;
    }else if ( typeof(variable) === 'object' ) {
   //   -----Object-----
        if (typeOfVar(variable) === 'array' && variable.length === 0) {
            console.log('\t Object Array with length = ' + [].length); // Object.keys(variable)
            return true;
        }else if (typeOfVar(variable) === 'string' && variable.length === 0 ) {
            console.log('\t Object String with length = ' + variable.length);
            return true;
        }else if (typeOfVar(variable) === 'boolean' ) {
            console.log('\t Object Boolean = ' + variable);
            return (variable === false) ? true : false;
        }else if (typeOfVar(variable) === 'number' ) {
            console.log('\t Object Number = ' + variable);
            return (variable === 0 ) ? true : false;
        }else if (typeOfVar(variable) === 'regexp' && variable.source.trim().length === 0 ) {
       console.log('\t Object Regular Expression : ');
        return true;
        }else if (variable === null) {
       console.log('\t Object null value');
        return true;
        }
    }
    return false;
}
var str = "A Basket For Every Occasion";
str = str.replace(/\s/g, "-");
//The "g" flag in the regex will cause all spaces to get replaced.

ตรวจสอบผลลัพธ์:

isVariableHaveDefaltVal(' '); // string          
isVariableHaveDefaltVal(false); // boolean       
var a;           
isVariableHaveDefaltVal(a);               
isVariableHaveDefaltVal(0); // number             
isVariableHaveDefaltVal(parseInt('')); // NAN isNAN(' '); - true         
isVariableHaveDefaltVal(null);              
isVariableHaveDefaltVal([]);               
isVariableHaveDefaltVal(/ /);              
isVariableHaveDefaltVal(new Object(''));               
isVariableHaveDefaltVal(new Object(false));            
isVariableHaveDefaltVal(new Object(0)); 
typeOfVar( function() {} );

ฉันใช้ @Vix function () เพื่อตรวจสอบวัตถุประเภทใด

ใช้ instansof «

var prototypes_or_Literals = function (obj) {
    switch (typeof(obj)) {
        // object prototypes
        case 'object':
            if (obj instanceof Array)
                return '[object Array]';
            else if (obj instanceof Date)
                return '[object Date]';
            else if (obj instanceof RegExp)
                return '[object regexp]';
            else if (obj instanceof String)
                return '[object String]';
            else if (obj instanceof Number)
                return '[object Number]';

            else
                return 'object';
        // object literals
        default:
            return typeof(obj);
    }   
};
output test «
prototypes_or_Literals( '' ) // "string"
prototypes_or_Literals( new String('') ) // "[object String]"
Object.prototype.toString.call("foo bar") //"[object String]"        

function isEmpty(obj) {
    if (typeof obj == 'number') return false;
    else if (typeof obj == 'string') return obj.length == 0;
    else if (Array.isArray(obj)) return obj.length == 0;
    else if (typeof obj == 'object') return obj == null || Object.keys(obj).length == 0;
    else if (typeof obj == 'boolean') return false;
    else return !obj;
}

ใน ES6 ที่มีการตัดแต่งเพื่อจัดการสตริง whitespace:

const isEmpty = value => {
    if (typeof value === 'number') return false
    else if (typeof value === 'string') return value.trim().length === 0
    else if (Array.isArray(value)) return value.length === 0
    else if (typeof value === 'object') return value == null || Object.keys(value).length === 0
    else if (typeof value === 'boolean') return false
    else return !value
}

มันอาจจะมีประโยชน์

ค่าทั้งหมดในอาเรย์แสดงถึงสิ่งที่คุณต้องการให้เป็น (โมฆะไม่ได้กำหนดหรืออื่น ๆ ) และคุณค้นหาสิ่งที่คุณต้องการ

var variablesWhatILookFor = [null, undefined, ''];
variablesWhatILookFor.indexOf(document.DocumentNumberLabel) > -1

หากคุณกำลังใช้TypeScriptและไม่ต้องการบัญชีสำหรับ"ค่าเหล่านั้นfalse"นี่คือคำตอบสำหรับคุณ:

ครั้งแรก: import { isNullOrUndefined } from 'util';

แล้ว: isNullOrUndefined(this.yourVariableName)

โปรดทราบ: ดังที่กล่าวไว้ด้านล่างนี้เลิกใช้แล้วvalue === undefined || value === nullแทน อ้าง

ความว่างเปล่า

ฉันไม่แนะนำให้พยายามกำหนดหรือใช้ฟังก์ชั่นที่คำนวณว่าค่าใด ๆ ในโลกนี้ว่างเปล่า การ "ว่างเปล่า" หมายความว่าอะไร? หากฉันมีlet human = { name: 'bob', stomach: 'empty' }ควรisEmpty(human)กลับมาtrue? หากฉันมีlet reg = new RegExp('');ควรisEmpty(reg)กลับมาtrue? แล้วisEmpty([ null, null, null, null ])- รายการนี้มี แต่ความว่างเปล่าเท่านั้นเองดังนั้นรายการจึงว่างเปล่า ฉันต้องการที่จะหยิบยกที่นี่บางบันทึกเกี่ยวกับ "ว่าง" (คำปิดบังเจตนาเพื่อหลีกเลี่ยงการสมาคมที่มีอยู่ก่อน) ใน javascript - และฉันต้องการที่จะยืนยันว่า "ว่าง" ในค่าจาวาสคริปต์ไม่ควรจัดการโดยทั่วไป

truthiness / Falsiness

สำหรับการตัดสินใจว่าจะหาค่า "ความไม่ว่าง" ของค่าได้นั้นเราจำเป็นต้องรองรับค่า inbuilt ของจาวาสคริปต์, ความรู้สึกโดยธรรมชาติของค่าที่เป็น "ความจริง" หรือ "เท็จ" โดยธรรมชาติnullและundefinedทั้งคู่ก็“ ผิดพลาด” น้อยกว่าอย่างเป็นธรรมชาติหมายเลข0(และไม่มีหมายเลขอื่นยกเว้นNaN) ก็เป็น "เท็จ" เช่นกัน อย่างน้อยตามธรรมชาติ: ''เป็นเท็จ แต่[]และ{}(และnew Set()และnew Map()) เป็นจริง - แม้ว่าพวกเขาทั้งหมดดูเหมือนว่างเปล่าอย่างเท่าเทียมกัน!

Null vs Undefined

นอกจากนี้ยังมีการอภิปรายเกี่ยวกับnullvs undefined- เราต้องการทั้งสองอย่างเพื่อแสดงความว่างเปล่าในโปรแกรมของเราหรือไม่? ฉันเองหลีกเลี่ยงที่จะมีตัวอักษร u, n, d, e, f, i, n, e, d ปรากฏในรหัสของฉันตามลำดับนั้น ฉันมักจะใช้nullเพื่อหมายถึง "ว่าง" อีกครั้งแม้ว่าเราต้องรองรับความรู้สึกโดยธรรมชาติจาวาสคริปต์ของวิธีการnullและundefinedแตกต่างกัน:

• พยายามเข้าถึงคุณสมบัติที่ไม่มีอยู่ให้ undefined
• การข้ามพารามิเตอร์เมื่อเรียกใช้ฟังก์ชันส่งผลให้พารามิเตอร์นั้นรับundefined:

let f = a => a;
console.log(f('hi'));
console.log(f());

• พารามิเตอร์ที่มีค่าเริ่มต้นจะได้รับค่าเริ่มต้นก็ต่อเมื่อได้รับundefinedไม่ใช่null:

let f = (v='hello') => v;
console.log(f(null));
console.log(f(undefined));

ไม่มีความว่างเปล่าทั่วไป

ฉันเชื่อว่าความว่างเปล่าไม่ควรได้รับการจัดการโดยทั่วไป เราควรมีความแม่นยำในการรับข้อมูลเพิ่มเติมเกี่ยวกับข้อมูลของเราเสมอก่อนที่จะพิจารณาว่ามันว่างเปล่าหรือไม่ - ฉันทำสิ่งนี้เป็นหลักโดยการตรวจสอบประเภทของข้อมูลที่ฉันจัดการกับ:

let isType = (value, Cls) => {
  try {
    return Object.getPrototypeOf(value).constructor === Cls;
  } catch(err) {
    return false;
  }
};

โปรดทราบว่าฟังก์ชั่นนี้จะไม่สนใจความแตกต่าง - คาดว่าvalueจะเป็นเช่นโดยตรงและไม่เป็นตัวอย่างของประเภทรองของCls Clsฉันหลีกเลี่ยงinstanceofด้วยเหตุผลหลักสองประการ:

• ([] instanceof Object) === true ("Array เป็นวัตถุ")
• ('' instanceof String) === false ("สตริงไม่ใช่สตริง")

โปรดทราบว่าObject.getPrototypeOfถูกนำมาใช้เพื่อหลีกเลี่ยงกรณีเช่นฟังก์ชั่นยังคงส่งกลับอย่างถูกต้องสำหรับ(เท็จ) และ(จริง)let v = { constructor: String };isTypeisType(v, String)isType(v, Object)

โดยรวมแล้วฉันแนะนำให้ใช้isTypeฟังก์ชั่นนี้พร้อมกับเคล็ดลับเหล่านี้:

• ลดจำนวนของค่าการประมวลผลรหัสประเภทที่ไม่รู้จักให้น้อยที่สุด เช่นสำหรับตัวแปรlet v = JSON.parse(someRawValue);ของเราvตอนนี้เป็นประเภทที่ไม่รู้จัก เร็วที่สุดที่เป็นไปได้เราควร จำกัด ความเป็นไปได้ของเรา วิธีที่ดีที่สุดที่จะทำนี้สามารถโดยการกำหนดประเภทเฉพาะ: เช่นif (!isType(v, Array)) throw new Error('Expected Array');- นี้เป็นวิธีที่รวดเร็วจริงๆและการแสดงออกที่จะเอาธรรมชาติทั่วไปและให้แน่ใจว่ามันเสมอv Arrayอย่างไรก็ตามบางครั้งเราจำเป็นต้องอนุญาตให้vมีหลายประเภท ในกรณีเหล่านี้เราควรสร้างกลุ่มของรหัสที่vไม่มีความหมายอีกต่อไปโดยเร็วที่สุด:

if (isType(v, String)) {
  /* v isn't generic in this block - It's a String! */
} else if (isType(v, Number)) {
  /* v isn't generic in this block - It's a Number! */
} else if (isType(v, Array)) {
  /* v isn't generic in this block - it's an Array! */
} else {
  throw new Error('Expected String, Number, or Array');
}

• ใช้ "รายชื่อที่อนุญาต" ทุกครั้งเพื่อตรวจสอบความถูกต้อง หากคุณต้องการค่าที่จะเป็นเช่น String, Number หรือ Array ให้ตรวจสอบความเป็นไปได้ทั้ง 3 "สีขาว" และโยนข้อผิดพลาดหากไม่มีทั้ง 3 ข้อ เราควรจะเห็นว่าการตรวจสอบความเป็นไปได้ "ดำ" นั้นไม่มีประโยชน์มาก: สมมติว่าเราเขียนif (v === null) throw new Error('Null value rejected');- นี่เป็นวิธีที่ดีในการตรวจสอบว่าnullค่าไม่สามารถทำได้ แต่ถ้าค่านั้นทำให้เป็นจริงเราก็ยังไม่ค่อยรู้ อะไรก็ได้เกี่ยวกับมัน ค่าvที่ผ่านการตรวจสอบโมฆะนี้ยังคงเป็นทั่วไปมาก - มันเป็นอะไร แต่null ! บัญชีดำแทบจะไม่ต้องกังวลกับคนทั่วไป

• หากไม่มีค่าใดnullๆ อย่าพิจารณา "ค่าที่ไม่มีค่า" ให้พิจารณา "x ซึ่งไม่มีความหมาย" แทน โดยพื้นฐานแล้วอย่าคิดว่าจะทำอะไรเช่นif (isEmpty(val)) { /* ... */ }- ไม่ว่าisEmptyจะใช้ฟังก์ชั่นนั้นได้อย่างไร (ฉันไม่อยากรู้ ... ) มันไม่มีความหมายเลย! และมันก็ธรรมดาเกินไป! ควรคำนวณความว่างเปล่าด้วยความรู้valประเภทเท่านั้น เช็คว่างเปล่าควรมีลักษณะเช่นนี้:

  • "สตริงที่ไม่มีตัวอักษร": if (isType(val, String) && val.length === 0) ...
  • "วัตถุกับอุปกรณ์ประกอบฉาก 0": if (isType(val, Object) && Object.entries(val).length === 0) ...
  • "ตัวเลขเท่ากับหรือน้อยกว่าศูนย์": if (isType(val, Number) && val <= 0) ...

  • "Array ไม่มีรายการ": if (isType(val, Array) && val.length === 0) ...

  • ข้อยกเว้นเพียงอย่างเดียวคือเมื่อnullใช้เพื่อบ่งชี้ถึงการทำงานบางอย่าง ในกรณีนี้มันมีความหมายที่จะพูดว่า: "ค่าที่ไม่ว่าง":if (val === null) ...

ลองด้วยเหตุผลที่แตกต่างกัน คุณสามารถใช้รหัสร้องเพื่อตรวจสอบเงื่อนไขทั้งสี่ (4) สำหรับการตรวจสอบเช่นไม่เป็นโมฆะไม่ว่างไม่ได้ไม่ได้กำหนดและไม่เป็นศูนย์เท่านั้นใช้รหัสนี้ (! (! (ตัวแปร))) ใน javascript และ jquery

function myFunction() {
    var data;  //The Values can be like as null, blank, undefined, zero you can test

    if(!(!(data)))
    {
        alert("data "+data);
    } 
    else 
    {
        alert("data is "+data);
    }
}

ดูตัวดำเนินการรวม ECMAScript Nullish แบบใหม่

คุณสามารถคิดว่าคุณลักษณะนี้ - ??ผู้ประกอบการ - เป็นวิธีการ“ตกกลับ” เป็นค่าเริ่มต้นได้เมื่อต้องรับมือกับหรือnullundefined

let x = foo ?? bar();

อีกครั้งรหัสข้างต้นเทียบเท่ากับดังต่อไปนี้

let x = (foo !== null && foo !== undefined) ? foo : bar();

function isEmpty(val){
    return !val;
}

แต่โซลูชันนี้มีการออกแบบมากเกินไปหากคุณไม่ต้องการแก้ไขฟังก์ชั่นในภายหลังสำหรับความต้องการของแบบจำลองธุรกิจ busines คุณควรใช้โค้ดนี้โดยตรงในโค้ด:

if(!val)...

var myNewValue = myObject && myObject.child && myObject.child.myValue;

สิ่งนี้จะไม่ทำให้เกิดข้อผิดพลาด ถ้าmyObject , childหรือmyValueเป็นโมฆะmyNewValueจะเป็นโมฆะ จะไม่มีข้อผิดพลาดเกิดขึ้น

สำหรับทุกคนที่มาที่นี่เพื่อมีคำถามที่คล้ายกันต่อไปนี้ใช้งานได้ดีและฉันมีมันในห้องสมุดของฉันในปีที่ผ่านมา:

(function(g3, $, window, document, undefined){
   g3.utils = g3.utils || {};
/********************************Function type()********************************
* Returns a lowercase string representation of an object's constructor.
* @module {g3.utils}
* @function {g3.utils.type}
* @public
* @param {Type} 'obj' is any type native, host or custom.
* @return {String} Returns a lowercase string representing the object's 
* constructor which is different from word 'object' if they are not custom.
* @reference http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
* http://stackoverflow.com/questions/3215046/differentiating-between-arrays-and-hashes-in-javascript
* http://javascript.info/tutorial/type-detection
*******************************************************************************/
g3.utils.type = function (obj){
   if(obj === null)
      return 'null';
   else if(typeof obj === 'undefined')
      return 'undefined';
   return Object.prototype.toString.call(obj).match(/^\[object\s(.*)\]$/)[1].toLowerCase();
};
}(window.g3 = window.g3 || {}, jQuery, window, document));

หากคุณต้องการหลีกเลี่ยงการได้รับจริงถ้าค่าใด ๆ ต่อไปนี้ตามคำตอบของ jAndy :

• โมฆะ
• ไม่ได้กำหนด
• น่าน
• สตริงว่าง ("")
• 0
• เท็จ

ทางออกหนึ่งที่เป็นไปได้ที่อาจหลีกเลี่ยงการได้รับคุณค่าที่แท้จริงคือ

function isUsable(valueToCheck) {
    if (valueToCheck === 0     || // Avoid returning false if the value is 0.
        valueToCheck === ''    || // Avoid returning false if the value is an empty string.
        valueToCheck === false || // Avoid returning false if the value is false.
        valueToCheck)             // Returns true if it isn't null, undefined, or NaN.
    {
        return true;
    } else {
        return false;
    }
}

มันจะถูกใช้ดังนี้:

if (isUsable(x)) {
    // It is usable!
}
// Make sure to avoid placing the logical NOT operator before the parameter (isUsable(!x)) and instead, use it before the function, to check the returned value.
if (!isUsable(x)) {
    // It is NOT usable!
}

นอกเหนือจากสถานการณ์เหล่านั้นคุณอาจต้องการคืนค่าเท็จถ้าวัตถุหรืออาร์เรย์ว่างเปล่า:

• วัตถุ: {} (ใช้ECMA 7+ )
• อาร์เรย์: [] (ใช้ECMA 5+ )

คุณจะทำมันด้วยวิธีนี้:

function isEmptyObject(valueToCheck) {
    if(typeof valueToCheck === 'object' && !Object.keys(valueToCheck).length){
        // Object is empty!
        return true;
    } else {
        // Object is not empty!
        return false;
    }
}

function isEmptyArray(valueToCheck) {
    if(Array.isArray(valueToCheck) && !valueToCheck.length) {
        // Array is empty!
        return true;
    } else {
        // Array is not empty!
        return false;
    }
}

หากคุณต้องการตรวจสอบสตริง whitespace ทั้งหมด ("") คุณสามารถทำสิ่งต่อไปนี้:

function isAllWhitespace(){
    if (valueToCheck.match(/^ *$/) !== null) {
        // Is all whitespaces!
        return true;
    } else {
        // Is not all whitespaces!
        return false;
    }
}

หมายเหตุ: hasOwnPropertyส่งคืนจริงสำหรับสตริงว่าง, 0, เท็จ, NaN, null และไม่ได้กำหนดหากตัวแปรถูกประกาศว่าเป็นหนึ่งในนั้นดังนั้นจึงอาจไม่ดีที่สุดที่จะใช้ ฟังก์ชันอาจถูกปรับเปลี่ยนเพื่อใช้เพื่อแสดงว่ามีการประกาศ แต่ไม่สามารถใช้งานได้

รหัสบน GitHub

const isEmpty = value => (
  (!value && value !== 0 && value !== false)
  || (Array.isArray(value) && value.length === 0)
  || (isObject(value) && Object.keys(value).length === 0)
  || (typeof value.size === 'number' && value.size === 0)

  // `WeekMap.length` is supposed to exist!?
  || (typeof value.length === 'number'
      && typeof value !== 'function' && value.length === 0)
);

// Source: https://levelup.gitconnected.com/javascript-check-if-a-variable-is-an-object-and-nothing-else-not-an-array-a-set-etc-a3987ea08fd7
const isObject = value =>
  Object.prototype.toString.call(value) === '[object Object]';

การทดสอบของคนจน😁

const test = () => {
  const run = (label, values, expected) => {
    const length = values.length;
    console.group(`${label} (${length} tests)`);
    values.map((v, i) => {
      console.assert(isEmpty(v) === expected, `${i}: ${v}`);
    });
    console.groupEnd();
  };

  const empty = [
    null, undefined, NaN, '', {}, [],
    new Set(), new Set([]), new Map(), new Map([]),
  ];
  const notEmpty = [
    ' ', 'a', 0, 1, -1, false, true, {a: 1}, [0],
    new Set([0]), new Map([['a', 1]]),
    new WeakMap().set({}, 1),
    new Date(), /a/, new RegExp(), () => {},
  ];
  const shouldBeEmpty = [
    {undefined: undefined}, new Map([[]]),
  ];

  run('EMPTY', empty, true);
  run('NOT EMPTY', notEmpty, false);
  run('SHOULD BE EMPTY', shouldBeEmpty, true);
};

ผลการทดสอบ:

EMPTY (10 tests)
NOT EMPTY (16 tests)
SHOULD BE EMPTY (2 tests)
  Assertion failed: 0: [object Object]
  Assertion failed: 1: [object Map]

การทำเช่นนี้จะตรวจสอบว่าตัวแปรของการซ้อนที่ไม่แน่นอนไม่ได้ถูกกำหนด

function Undef(str) 
{
  var ary = str.split('.');
  var w = window;
  for (i in ary) {
    try      { if (typeof(w = w[ary[i]]) === "undefined") return true; }
    catch(e) { return true; }
  }
  return false;
}

if (!Undef("google.translate.TranslateElement")) {

ตรวจสอบข้างต้นว่า Google TranslateElement ฟังก์ชั่นที่มีอยู่ นี่เทียบเท่ากับ:

if (!(typeof google === "undefined" 
 || typeof google.translate === "undefined" 
 || typeof google.translate.TranslateElement === "undefined")) {

โอเปอเรเตอร์เสริมที่เป็นตัวเลือกมีวิธีในการลดความซับซ้อนในการเข้าถึงค่าผ่านทางวัตถุที่เชื่อมต่อเมื่อเป็นไปได้ว่าการอ้างอิงหรือฟังก์ชั่นอาจไม่ได้กำหนดหรือเป็นโมฆะ

let customer = {
  name: "Carl",
  details: {
    age: 82,
    location: "Paradise Falls" // detailed address is unknown
  }
};
let customerCity = customer.details?.address?.city;

ตัวดำเนินการรวมศูนย์ nullish อาจถูกนำมาใช้หลังจากการผูกมัดตัวเลือกเพื่อสร้างค่าเริ่มต้นเมื่อไม่พบ:

let customer = {
  name: "Carl",
  details: { age: 82 }
};
const customerCity = customer?.city ?? "Unknown city";
console.log(customerCity); // Unknown city

function notEmpty(value){
  return (typeof value !== 'undefined' && value.trim().length);
}

มันจะตรวจสอบช่องว่างสีขาว ('') พร้อมกับสิ่งต่อไปนี้:

• null, ไม่ได้กำหนด, NaN, ว่างเปล่า, สตริง (""), 0, false

ฉันคิดว่าใช้ ผู้ประกอบการสะอาดขึ้นเล็กน้อย

var ? function_if_exists() : function_if_doesnt_exist();