ฉันจะตรวจสอบค่าว่างใน JavaScript ได้อย่างไร

ฉันจะตรวจสอบค่าว่างใน JavaScript ได้อย่างไร ฉันเขียนโค้ดด้านล่าง แต่มันไม่ทำงาน

if (pass == null || cpass == null || email == null || cemail == null || user == null) {      

    alert("fill all columns");
    return false;  

}   

และฉันจะหาข้อผิดพลาดในโปรแกรม JavaScript ได้อย่างไร

Javascript มีความยืดหยุ่นสูงในเรื่องการตรวจสอบค่า "null" ฉันเดาว่าคุณกำลังมองหาสตริงว่างเปล่าซึ่งในกรณีนี้รหัสที่ง่ายกว่านี้จะทำงาน:

if(!pass || !cpass || !email || !cemail || !user){

ซึ่งจะตรวจสอบสำหรับสตริงว่าง ( "") null, undefined, falseและตัวเลข0และNaN

โปรดทราบว่าหากคุณกำลังตรวจสอบหมายเลขโดยเฉพาะมันเป็นความผิดพลาดทั่วไปที่จะพลาด0ด้วยวิธีนี้และnum !== 0เป็นที่ต้องการ ( num !== -1หรือ~num( หรือ(แฮ็กโค้ดที่ตรวจสอบด้วย-1)) สำหรับฟังก์ชั่นที่ส่งคืน-1เช่นindexOf)

เพื่อตรวจสอบ null เฉพาะที่คุณจะใช้นี้

if (variable === null)

การทดสอบนี้จะเฉพาะผ่านสำหรับnullและจะไม่ผ่านสำหรับ"", undefined, false, หรือ0NaN

นอกจากนี้ฉันได้ให้การตรวจสอบที่แน่นอนสำหรับค่า "เหมือนจริง" แต่ละรายการ (รายการหนึ่งที่จะส่งกลับค่าจริงสำหรับ!variable)

หมายเหตุสำหรับบางส่วนของการตรวจสอบแน่นอนคุณจะต้องดำเนินการใช้และabsolutely equals: ===typeof

ฉันได้สร้างJSFiddleที่นี่เพื่อแสดงการทดสอบแต่ละรายการที่ใช้การได้

นี่คือผลลัพธ์ของการตรวจสอบแต่ละครั้ง:

Null Test:

if (variable === null)

- variable = ""; (false) typeof variable = string

- variable = null; (true) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Empty String Test:

if (variable === '')

- variable = ''; (true) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number




Undefined Test:

if (typeof variable == "undefined")

-- or --

if (variable === undefined)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (true) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



False Test:

if (variable === false)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (true) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Zero Test:

if (variable === 0)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (true) typeof variable = number

- variable = NaN; (false) typeof variable = number



NaN Test:

if (typeof variable == 'number' && !parseFloat(variable) && variable !== 0)

-- or --

if (isNaN(variable))

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (true) typeof variable = number

ขณะที่คุณสามารถดูจะเล็ก ๆ น้อย ๆ ที่ยากขึ้นไปทดสอบกับNaN;

เพียงแทนที่==ด้วย===ในทุกสถานที่

== เป็นการเปรียบเทียบความเท่าเทียมหรือหลวม

=== เป็นการเปรียบเทียบความเท่าเทียมอย่างเข้มงวด

ดูบทความ MDN เกี่ยวกับการเปรียบเทียบความเท่าเทียมกันและความเหมือนกันสำหรับรายละเอียดเพิ่มเติม

ตัวดำเนินการที่เท่าเทียมกันอย่างเข้มงวด: -

เราสามารถตรวจสอบโมฆะโดย ===

if ( value === null ){

}

เพียงแค่ใช้ if

if( value ) {

}

จะประเมินค่าเป็นจริงหากค่าไม่ใช่ :

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

ปรับปรุงคำตอบที่ได้รับการยอมรับโดยการตรวจสอบอย่างชัดเจนnullแต่ใช้ไวยากรณ์ที่ง่ายขึ้น:

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
}

// Test
let pass=1, cpass=1, email=1, cemail=1, user=1; // just to test

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
    console.log ("Yayy! None of them are null");
} else {
    console.log ("Oops! At-lease one of them is null");
}

ประการแรกคุณมีคำสั่ง return โดยไม่มีส่วนของฟังก์ชั่น โอกาสที่จะเกิดข้อผิดพลาด

วิธีที่สะอาดกว่าในการทำเช็คของคุณคือใช้! ผู้ประกอบการ:

if (!pass || !cpass || !email || !cemail || !user) {

    alert("fill all columns");

}

คุณสามารถใช้ลองจับได้ในที่สุด

 try {
     document.getElementById("mydiv").innerHTML = 'Success' //assuming "mydiv" is undefined
 } catch (e) {

     if (e.name.toString() == "TypeError") //evals to true in this case
     //do something

 } finally {}   

คุณสามารถthrowแก้ไขข้อผิดพลาดของคุณเอง ดูนี่สิ

ใน JavaScript nullสตริงไม่เท่ากับ

บางทีคุณอาจคาดหวังว่าpass == nullจะเป็นจริงเมื่อpassเป็นสตริงว่างเปล่าเพราะคุณทราบว่าตัว==ดำเนินการความเท่าเทียมกันแบบหลวมนั้นมีการข่มขู่ประเภทบางประเภท

ตัวอย่างเช่นการแสดงออกนี้เป็นจริง:

'' == 0

ในทางตรงกันข้ามผู้ดำเนินการความเท่าเทียมอย่างเข้มงวด===กล่าวว่าสิ่งนี้เป็นเท็จ

'' === 0

ระบุว่า''และ0มีความเท่าเทียมกันอย่างหลวม ๆ คุณอาจมีเหตุผลการคาดเดาว่า''และnullมีความเท่าเทียมกันอย่างหลวม ๆ อย่างไรก็ตามพวกเขาไม่ได้

การแสดงออกนี้เป็นเท็จ:

'' == null

ผลลัพธ์ของการเปรียบเทียบสตริงใด ๆ กับnullเป็นเท็จ ดังนั้นpass == nullและการทดสอบอื่น ๆ ทั้งหมดของคุณเป็นเท็จเสมอและผู้ใช้จะไม่ได้รับการแจ้งเตือน

ในการแก้ไขรหัสของคุณให้เปรียบเทียบแต่ละค่ากับสตริงว่าง:

pass === ''

หากคุณแน่ใจว่าpassเป็นสตริงpass == ''ก็จะทำงานได้เช่นกันเพราะมีเพียงสตริงว่างเปล่าเท่านั้นที่เท่ากับสตริงว่าง ในทางกลับกันผู้เชี่ยวชาญบางคนบอกว่าเป็นแนวปฏิบัติที่ดีที่จะใช้ความเสมอภาคที่เข้มงวดใน JavaScript เสมอเว้นแต่คุณต้องการทำแบบบังคับชนิดที่ตัวดำเนินการความเท่าเทียมกันแบบหลวมทำมาโดยเฉพาะ

หากคุณต้องการทราบว่าค่าใดที่มีค่าเท่ากันให้ดูตาราง "การเปรียบเทียบแบบ Sameness" ในบทความ Mozilla ในหัวข้อนี้

เพื่อตรวจสอบundefinedและnullใน javascript คุณต้องเขียนดังนี้:

if (!var) {
        console.log("var IS null or undefined");
} else {
        console.log("var is NOT null or undefined");
}

นี่คือความคิดเห็นเกี่ยวกับวิธีแก้ปัญหาของ WebWanderer เกี่ยวกับการตรวจสอบสำหรับ NaN (ฉันยังไม่มีตัวแทนมากพอที่จะแสดงความคิดเห็นอย่างเป็นทางการ) การแก้ปัญหาอ่านว่า

if(!parseInt(variable) && variable != 0 && typeof variable === "number")

แต่นี้จะล้มเหลวสำหรับตัวเลขที่มีเหตุผลซึ่งจะปัดเศษเช่น0 variable = 0.1การทดสอบที่ดีกว่าคือ:

if(isNaN(variable) && typeof variable === "number")

ที่จริงฉันคิดว่าคุณอาจต้องใช้ if (value !== null || value !== undefined) เพราะถ้าคุณใช้if (value)คุณอาจกรอง 0 หรือค่าเท็จ

พิจารณาทั้งสองฟังก์ชั่น:

const firstTest = value => {
    if (value) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}
const secondTest = value => {
    if (value !== null && value !== undefined) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}

firstTest(0);            // result: failed
secondTest(0);           // result: passed

firstTest(false);        // result: failed
secondTest(false);       // result: passed

firstTest('');           // result: failed
secondTest('');          // result: passed

firstTest(null);         // result: failed
secondTest(null);        // result: failed

firstTest(undefined);    // result: failed
secondTest(undefined);   // result: failed

ในสถานการณ์ของฉันฉันแค่ต้องตรวจสอบว่าค่าเป็นโมฆะและไม่ได้กำหนดและฉันไม่ต้องการที่จะกรอง0หรือfalseหรือ''ค่า ดังนั้นฉันจึงใช้การทดสอบครั้งที่สอง แต่คุณอาจต้องกรองพวกเขาด้วยซึ่งอาจทำให้คุณใช้การทดสอบครั้งแรก

ฉันพบวิธีอื่นในการทดสอบว่าค่าเป็นโมฆะหรือไม่:

if(variable >= 0 && typeof variable === "object")

nullทำหน้าที่เป็นnumberและobjectในเวลาเดียวกัน เปรียบเทียบnull >= 0หรือผลลัพธ์ในnull <= 0 trueเปรียบเทียบnull === 0หรือnull > 0หรือnull < 0จะส่งผลให้การเท็จ แต่nullก็ยังเป็นวัตถุที่เราสามารถตรวจพบว่ามันเป็นโมฆะ

ฉันทำฟังก์ชั่นที่ซับซ้อนมากขึ้นnatureofแม่มดจะทำดีกว่า typeof และสามารถบอกสิ่งที่ประเภทเพื่อรวมหรือให้จัดกลุ่ม

/* function natureof(variable, [included types])
included types are 
    null - null will result in "undefined" or if included, will result in "null"
    NaN - NaN will result in "undefined" or if included, will result in "NaN"
    -infinity - will separate negative -Inifity from "Infinity"
    number - will split number into "int" or "double"
    array - will separate "array" from "object"
    empty - empty "string" will result in "empty" or
    empty=undefined - empty "string" will result in "undefined"
*/
function natureof(v, ...types){
/*null*/            if(v === null) return types.includes('null') ? "null" : "undefined";
/*NaN*/             if(typeof v == "number") return (isNaN(v)) ? types.includes('NaN') ? "NaN" : "undefined" : 
/*-infinity*/       (v+1 === v) ? (types.includes('-infinity') && v === Number.NEGATIVE_INFINITY) ? "-infinity" : "infinity" : 
/*number*/          (types.includes('number')) ? (Number.isInteger(v)) ? "int" : "double" : "number";
/*array*/           if(typeof v == "object") return (types.includes('array') && Array.isArray(v)) ? "array" : "object";
/*empty*/           if(typeof v == "string") return (v == "") ? types.includes('empty') ? "empty" : 
/*empty=undefined*/ types.includes('empty=undefined') ? "undefined" : "string" : "string";
                    else return typeof v
}

// DEMO
let types = [null, "", "string", undefined, NaN, Infinity, -Infinity, false, "false", true, "true", 0, 1, -1, 0.1, "test", {var:1}, [1,2], {0: 1, 1: 2, length: 2}]

for(i in types){
console.log("natureof ", types[i], " = ", natureof(types[i], "null", "NaN", "-infinity", "number", "array", "empty=undefined")) 
}

ฉันสร้างฟังก์ชั่นง่าย ๆ ที่ใช้งานได้ดีมาก:

function safeOrZero(route) {
  try {
    Function(`return (${route})`)();
  } catch (error) {
    return 0;
  }
  return Function(`return (${route})`)();
}

เส้นทางเป็นสิ่งที่มีค่าที่สามารถระเบิดได้ ฉันใช้สำหรับ jQuery / cheerio และวัตถุและเช่น

ตัวอย่างที่ 1: const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};วัตถุง่ายๆเช่นนี้

แต่มันอาจเป็นวัตถุที่มีขนาดใหญ่มากที่เราไม่ได้ทำ ดังนั้นฉันผ่านมันไป:

let value1 = testobj.items[2].val;  // "hum!"
let value2 = testobj.items[3].val;  // Uncaught TypeError: Cannot read property 'val' of undefined

let svalue1 = safeOrZero(`testobj.items[2].val`)  // "hum!"
let svalue2 = safeOrZero(`testobj.items[3].val`)  // 0

แน่นอนถ้าคุณต้องการคุณสามารถใช้nullหรือ'No value'... สิ่งที่เหมาะกับความต้องการของคุณ

โดยปกติแล้วแบบสอบถาม DOM หรือตัวเลือก jQuery อาจมีข้อผิดพลาดหากไม่พบ แต่ใช้สิ่งที่ชอบ:

const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
  [...]
}

คุณสามารถใช้โมดูลบ้านพักเพื่อตรวจสอบค่าเป็นโมฆะหรือไม่ได้กำหนด

_.isNil(value)
Example 

 country= "Abc"
    _.isNil(country)
    //false

   state= null
    _.isNil(state)
    //true

city= undefined
    _.isNil(state)
    //true

   pin= true
    _.isNil(pin)
    // false   

ลิงค์อ้างอิง: https://lodash.com/docs/#isNil

สิ่งนี้จะไม่ทำงานในกรณีที่ค่าบูลีนมาจากฐานข้อมูลเช่น:

 value = false

 if(!value) {
   // it will change all false values to not available
   return "not available"
 }

AFAIK ในJAVASCRIPTเมื่อตัวแปรประกาศundefinedแต่ยังไม่ได้รับมอบหมายค่าชนิดของมันคือ เพื่อให้เราสามารถตรวจสอบตัวแปรแม้ว่ามันจะเป็นobjectบางคนถือเช่นในสถานที่ของมูลค่า

สร้างวิธีการช่วยเหลือสำหรับการตรวจสอบความว่างเปล่าที่ส่งคืนtrueและใช้ใน API ของคุณ

ฟังก์ชั่นผู้ช่วยเพื่อตรวจสอบว่าตัวแปรว่างเปล่า:

function isEmpty(item){
    if(item){
        return false;
    }else{
        return true;
    }
}

ลองเรียก API พิเศษ:

try {

    var pass, cpass, email, cemail, user; // only declared but contains nothing.

    // parametrs checking
    if(isEmpty(pass) || isEmpty(cpass) || isEmpty(email) || isEmpty(cemail) || isEmpty(user)){
        console.log("One or More of these parameter contains no vlaue. [pass] and-or [cpass] and-or [email] and-or [cemail] and-or [user]");
    }else{
        // do stuff
    }

} catch (e) {
    if (e instanceof ReferenceError) {
        console.log(e.message); // debugging purpose
        return true;
    } else {
        console.log(e.message); // debugging purpose
        return true;
    }
}

กรณีทดสอบบางส่วน:

var item = ""; // isEmpty? true
var item = " "; // isEmpty? false
var item; // isEmpty? true
var item = 0; // isEmpty? true
var item = 1; // isEmpty? false
var item = "AAAAA"; // isEmpty? false
var item = NaN; // isEmpty? true
var item = null; // isEmpty? true
var item = undefined; // isEmpty? true

console.log("isEmpty? "+isEmpty(item));

การตรวจสอบเงื่อนไขข้อผิดพลาด:

// Typical API response data
let data = {
  status: true,
  user: [],
  total: 0,
  activity: {sports: 1}
}

// A flag that checks whether all conditions were met or not
var passed = true;

// Boolean check
if (data['status'] === undefined || data['status'] == false){
  console.log("Undefined / no `status` data");
  passed = false;
}

// Array/dict check
if (data['user'] === undefined || !data['user'].length){
  console.log("Undefined / no `user` data");
  passed = false;
}

// Checking a key in a dictionary
if (data['activity'] === undefined || data['activity']['time'] === undefined){
   console.log("Undefined / no `time` data");
   passed = false;
}

// Other values check
if (data['total'] === undefined || !data['total']){
  console.log("Undefined / no `total` data");
  passed = false;
}

// Passed all tests?
if (passed){
  console.log("Passed all tests");
}

ลองสิ่งนี้:

if (!variable && typeof variable === "object") {
    // variable is null
}