जावास्क्रिप्ट में कुछ जाँच रहा है?

Question 1

जावास्क्रिप्ट में एक चर खाली होने पर मैं कैसे जांच सकता हूं? बेवकूफ सवाल के लिए क्षमा करें, लेकिन मैं जावास्क्रिप्ट में नौसिखिया हूँ!

if(response.photo) is empty {
    do something
else {
    do something else
}

response.photoJSON से था, और यह कभी-कभी खाली हो सकता है, खाली डेटा सेल! अगर खाली है तो जांच करना चाहता हूं।

Question 2

यदि आप एक खाली स्ट्रिंग के लिए परीक्षण कर रहे हैं:

if(myVar === ''){ // do stuff };

यदि आप एक ऐसे चर की जाँच कर रहे हैं जिसे घोषित किया गया है, लेकिन परिभाषित नहीं किया गया है:

if(myVar === null){ // do stuff };

यदि आप एक ऐसे चर की जाँच कर रहे हैं जिसे परिभाषित नहीं किया जा सकता है:

if(myVar === undefined){ // do stuff };

यदि आप दोनों की जाँच कर रहे हैं, या तो चर शून्य या अपरिभाषित है:

if(myVar == null){ // do stuff };

Question 3

आपके विचार से यह एक बड़ा प्रश्न है। चर बहुत तरीकों से खाली कर सकते हैं। किन्दा उस पर निर्भर करता है जिसे आपको जानना आवश्यक है।

// quick and dirty will be true for '', null, undefined, 0, NaN and false.
if (!x) 

// test for null OR undefined
if (x == null)  

// test for undefined OR null 
if (x == undefined) 

// test for undefined
if (x === undefined) 
// or safer test for undefined since the variable undefined can be set causing tests against it to fail.
if (typeof x == 'undefined') 

// test for empty string
if (x === '') 

// if you know its an array
if (x.length == 0)  
// or
if (!x.length)

// BONUS test for empty object
var empty = true, fld;
for (fld in x) {
  empty = false;
  break;
}

Question 4

यह सभी मामलों को कवर करना चाहिए:

function empty( val ) {

    // test results
    //---------------
    // []        true, empty array
    // {}        true, empty object
    // null      true
    // undefined true
    // ""        true, empty string
    // ''        true, empty string
    // 0         false, number
    // true      false, boolean
    // false     false, boolean
    // Date      false
    // function  false

        if (val === undefined)
        return true;

    if (typeof (val) == 'function' || typeof (val) == 'number' || typeof (val) == 'boolean' || Object.prototype.toString.call(val) === '[object Date]')
        return false;

    if (val == null || val.length === 0)        // null or 0 length array
        return true;

    if (typeof (val) == "object") {
        // empty object

        var r = true;

        for (var f in val)
            r = false;

        return r;
    }

    return false;
}

Question 5

मैं ऊपर पोस्ट किए गए कई समाधानों में संभावित कमियों को देखता हूं, इसलिए मैंने अपना खुद का संकलन करने का फैसला किया।
नोट: यह Array.prototyp.some का उपयोग करता है , अपने ब्राउज़र समर्थन की जाँच करें।

नीचे दिए गए समाधान चर को खाली मानते हैं यदि निम्न में से कोई एक सत्य है:

जे एस का मानना है कि चर के बराबर होता है false, जो पहले से ही की तरह बहुत सी बातें शामिल हैं 0, "", [], और यहां तक कि [""]और[0]
मान है null या यह टाइप है'undefined'
यह एक खाली वस्तु है
यह एक ऐसा ऑब्जेक्ट / एरे है जिसमें केवल ऐसे मान होते हैं जो स्वयं खाली होते हैं (अर्थात इसके प्रत्येक भाग के प्राइमिटिव्स तक टूट जाते हैं false)। जाँच वस्तु / सरणी संरचना में पुनरावर्ती ड्रिल करता है। उदाहरण के लिए
```
isEmpty({"": 0}) // true
isEmpty({"": 1}) // false
isEmpty([{}, {}])  // true
isEmpty(["", 0, {0: false}]) //true
```

समारोह कोड:

/**
 * Checks if value is empty. Deep-checks arrays and objects
 * Note: isEmpty([]) == true, isEmpty({}) == true, isEmpty([{0:false},"",0]) == true, isEmpty({0:1}) == false
 * @param value
 * @returns {boolean}
 */
function isEmpty(value){
  var isEmptyObject = function(a) {
    if (typeof a.length === 'undefined') { // it's an Object, not an Array
      var hasNonempty = Object.keys(a).some(function nonEmpty(element){
        return !isEmpty(a[element]);
      });
      return hasNonempty ? false : isEmptyObject(Object.keys(a));
    }

    return !a.some(function nonEmpty(element) { // check if array is really not empty as JS thinks
      return !isEmpty(element); // at least one element should be non-empty
    });
  };
  return (
    value == false
    || typeof value === 'undefined'
    || value == null
    || (typeof value === 'object' && isEmptyObject(value))
  );
}

Question 6

यहाँ मेरा सबसे सरल उपाय है।

PHP empty फ़ंक्शन से प्रेरित

function empty(n){
	return !(!!n ? typeof n === 'object' ? Array.isArray(n) ? !!n.length : !!Object.keys(n).length : true : false);
}

//with number
console.log(empty(0));        //true
console.log(empty(10));       //false

//with object
console.log(empty({}));       //true
console.log(empty({a:'a'}));  //false

//with array
console.log(empty([]));       //true
console.log(empty([1,2]));    //false

//with string
console.log(empty(''));       //true
console.log(empty('a'));      //false

स्निपेट का विस्तार करें

Question 7

Http://underscorejs.org/#isEmpty देखें

isEmpty_.isEmpty (ऑब्जेक्ट) यदि किसी एन्यूमरेबल ऑब्जेक्ट में कोई मान नहीं है (कोई एन्यूमरेबल स्वयं-प्रॉपर्टीज) नहीं है, तो सत्य है। स्ट्रिंग और सरणी जैसी वस्तुओं के लिए _.isEmpty जांचें यदि लंबाई संपत्ति 0 है।

Question 8

एक समारोह में @inkednm से उत्तर का संयोजन:

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

Question 9

JSON की कुंजी पर खाली चेक उपयोग-केस पर निर्भर करता है। एक सामान्य उपयोग के मामले में, हम निम्नलिखित के लिए परीक्षण कर सकते हैं:

नहीं null
नहीं undefined
खाली स्ट्रिंग नहीं ''
एक खाली वस्तु नहीं है {} [] (ऐरे एक वस्तु है)

समारोह:

function isEmpty(arg){
  return (
    arg == null || // Check for null or undefined
    arg.length === 0 || // Check for empty String (Bonus check for empty Array)
    (typeof arg === 'object' && Object.keys(arg).length === 0) // Check for empty Object or Array
  );
}

इसके लिए सही लौटें:

isEmpty(''); // Empty String
isEmpty(null); // null
isEmpty(); // undefined
isEmpty({}); // Empty Object
isEmpty([]); // Empty Array

Question 10

बस अगर कोई शर्त है, तो चर को किसी भी मान के अंदर रखें, यह सही और गलत है।

if (response.photo){ // if you are checking for string use this if(response.photo == "") condition
 alert("Has Value");
}
else
{
 alert("No Value");
};

Question 11

इस तरह से करने के बारे में क्या।

JSON.stringify({}) === "{}"

Question 12

यह निर्भर करता है कि आप "खाली" से क्या मतलब है। सबसे सामान्य पैटर्न यह देखना है कि चर अपरिभाषित है या नहीं । उदाहरण के लिए, कई लोग एक अशक्त जांच भी करते हैं:
if (myVariable === undefined || myVariable === null)...

या, छोटे रूप में:
if (myVariable || myVariable === null)...

Question 13

if (myVar == undefined)

यह देखने के लिए काम करेगा कि क्या संस्करण घोषित किया गया है, लेकिन नहीं।

Question 14

अपरिभाषित के लिए जाँच करें:

if (typeof response.photo == "undefined")
{
    // do something
}

यह vb के विषुव को करेगा IsEmpty । यदि मायवर में कोई मान है, यहां तक कि अशक्त, खाली स्ट्रिंग या 0, तो यह "खाली" नहीं है।

यह जाँचने के लिए कि एक चर या संपत्ति मौजूद है, उदाहरण के लिए, यह घोषित किया गया है, हालांकि यह परिभाषित नहीं किया गया है, आप inऑपरेटर का उपयोग कर सकते हैं ।

if ("photo" in response)
{
    // do something
}

Question 15

यदि आप PHP के emptyफ़ंक्शन के बराबर देख रहे हैं , तो इसे देखें:

function empty(mixed_var) {
  //   example 1: empty(null);
  //   returns 1: true
  //   example 2: empty(undefined);
  //   returns 2: true
  //   example 3: empty([]);
  //   returns 3: true
  //   example 4: empty({});
  //   returns 4: true
  //   example 5: empty({'aFunc' : function () { alert('humpty'); } });
  //   returns 5: false

  var undef, key, i, len;
  var emptyValues = [undef, null, false, 0, '', '0'];

  for (i = 0, len = emptyValues.length; i < len; i++) {
    if (mixed_var === emptyValues[i]) {
      return true;
    }
  }

  if (typeof mixed_var === 'object') {
    for (key in mixed_var) {
      // TODO: should we check for own properties only?
      //if (mixed_var.hasOwnProperty(key)) {
      return false;
      //}
    }
    return true;
  }

  return false;
}

http://phpjs.org/functions/empty:392

Question 16

मुझे क्या याद आ रहा है अगर खाली एरे ... कीलेस ऑब्जेक्ट ... फ़ालिसिटी कास्ट isEmpty = o => Array.isArray (o) &&! o.join ('') लंबाई typeof o === 'ऑब्जेक्ट' &&! object.keys (o) .length || ! (+ मूल्य);

Question 17

यहाँ खाली चर की जाँच करने के लिए एक सरल (संक्षिप्त) समाधान है। यह फ़ंक्शन जाँचता है कि कोई चर खाली है या नहीं। प्रदान किए गए चर में मिश्रित मूल्य (शून्य, अपरिभाषित, सरणी, ऑब्जेक्ट, स्ट्रिंग, पूर्णांक, फ़ंक्शन) हो सकते हैं।

function empty(mixed_var) {
 if (!mixed_var || mixed_var == '0') {
  return true;
 }
 if (typeof mixed_var == 'object') {
  for (var k in mixed_var) {
   return false;
  }
  return true;
 }
 return false;
}

//   example 1: empty(null);
//   returns 1: true

//   example 2: empty(undefined);
//   returns 2: true

//   example 3: empty([]);
//   returns 3: true

//   example 4: empty({});
//   returns 4: true

//   example 5: empty(0);
//   returns 5: true

//   example 6: empty('0');
//   returns 6: true

//   example 7: empty(function(){});
//   returns 7: false

Question 18

const isEmpty = val => val == null || !(Object.keys(val) || val).length;

Question 19

function isEmpty(variable) {
  const type = typeof variable
  if (variable === null) return true
  if (type === 'undefined') return true
  if (type === 'boolean') return false
  if (type === 'string') return !variable
  if (type === 'number') return false
  if (Array.isArray(variable)) return !variable.length
  if (type === 'object') return !Object.keys(variable).length
  return !variable
}

स्निपेट का विस्तार करें