විචල්ය එය බව, වටිනාකම සහ වගකීම බව චෙක්පත් බව විශ්ව JavaScript උත්සවය පවතී undefinedහෝ null? මට මෙම කේතය ඇත, නමුත් එය සියලු අවස්ථා ආවරණය කරයිදැයි මට විශ්වාස නැත:

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

නම්, ඔබ පරීක්ෂා කළ හැක විචල්ය සතුව truthyහෝ වටිනාකම නොවේ. ඒ කියන්නේ

if( value ) {
}

කිරීමට සලකා බලනු ඇත trueනම් valueවේ නොහැකි :

• ශුන්‍යයි
• නිර්වචනය නොකළ
• නා
• හිස් නූල ("")
• 0
• බොරු

ඉහත ලැයිස්තුව falsyECMA- / 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

අගය නිර්වචනය කර හෝ ශුන්‍ය දැයි පරීක්ෂා කිරීමට වාචික ක්‍රමය:

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 (ස්ට්රෝමන්) යෝජනාවකි." - සයිමන් කෙජල්බර්ග්. රාජකීය ආරෝහණ ලබා ගැනීම සඳහා මෙම සුන්දර යෝජනාවට කතුවරයා සිය සහය එක් කිරීමට අපේක්ෂා කරයි.

හොඳම ශ්‍රේණිගත කිරීම සහිත පළමු පිළිතුර වැරදිය. අගය නිර්වචනය කර නොමැති නම් එය නවීන බ්‍රව්සර්වල ව්‍යතිරේකයක් දමනු ඇත. ඔබ භාවිතා කළ යුත්තේ:

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

හෝ

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

මෙම තත්වය පරීක්ෂා කිරීම

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

ඔබට අවශ්‍ය වන්නේ එයයි.

! සඳහා පරීක්ෂා කරන්න හිස් නූල් ( ""), ශුන්ය, නිර්වචනය නොකළ එකක් වීම ගැන, සහ ව්යාජ සංඛ්යාව 0 සහ නන්. කියන්න, නූලක් හිස් var name = ""නම් console.log(!name)නැවත පැමිණේ true.

function isEmpty(val){
  return !val;
}

මෙම ශ්රිතය නම් සැබෑ ආපසු Val වේ සංඛ්යාව 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;
  }

එසේ නොමැතිනම්, ඔබ දැනටමත් යටි ඉරි හෝ ලොඩාෂ් භාවිතා කරන්නේ නම්, උත්සාහ කරන්න:

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

ප්‍රති ult ලය පරීක්ෂා කරන්න:

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() {} );

කුමන වර්ගයේ වස්තුව පරීක්ෂා කිරීමට මම ixVix ශ්‍රිතය () භාවිතා කළෙමි.

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 හි:

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ඒ වෙනුවට භාවිතා කරන්න. ref .

රික්තය

මුළු ලෝකයේම වටිනාකමක් හිස් දැයි ගණනය කරන ශ්‍රිතයක් නිර්වචනය කිරීමට හෝ භාවිතා කිරීමට උත්සාහ කිරීම මම නිර්දේශ නොකරමි. “හිස්” යන්නෙන් ඇත්තටම අදහස් කරන්නේ කුමක්ද? මා සතුව let human = { name: 'bob', stomach: 'empty' }ඇත්නම් isEmpty(human)ආපසු යා trueයුතුද? මා සතුව let reg = new RegExp('');ඇත්නම් isEmpty(reg)ආපසු යා trueයුතුද? කුමක් ගැනද isEmpty([ null, null, null, null ])- මෙම ලැයිස්තුවේ ඇත්තේ හිස් බව පමණි, එබැවින් ලැයිස්තුවම හිස්ද? ජාවාස්ක්‍රිප්ට් හි “රික්තය” (හිතාමතාම අපැහැදිලි වචනයක්, පෙර පැවති ඇසුරෙන් වැළකී සිටීම) පිළිබඳ සටහන් මෙහි ඉදිරිපත් කිරීමට මට අවශ්‍යය - ජාවාස්ක්‍රිප්ට් අගයන්හි “රික්තය” කිසි විටෙකත් සාමාන්‍යයෙන් නොසැලකිය යුතු යැයි තර්ක කිරීමට මට අවශ්‍යය.

සත්‍යය / මුසාවාදය

සාරධර්මවල “රික්තය” තීරණය කරන්නේ කෙසේද යන්න තීරණය කිරීම සඳහා, සාරධර්ම “සත්‍ය” හෝ “ව්‍යාජ” ද යන්න පිළිබඳ ජාවාස්ක්‍රිප්ට්හි ආවේනික, ආවේනික හැඟීම අප විසින් සකස් කළ යුතුය. ස්වාභාවිකවම, nullසහ undefinedදෙකම "ව්‍යාජ" වේ. ස්වභාවිකවම, අංකය 0(සහ වෙනත් සංඛ්‍යාවක් හැර NaN) ද "ව්‍යාජ" ය. අවම වශයෙන් ස්වභාවිකව: ''falsy, නමුත් []සහ {}(හා new Set(), හා new Map()) truthy ඇත - ඒ සෑම දැත්තක්ම එක හා සමාන අරුත් සුන් පෙනේ වුවත්!

Null vs නිර්වචනය නොකළ

nullඑදිරිව එදිරිව යම් සාකච්ඡාවක් ද ඇත 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 ("අරාව යනු වස්තුවකි")
• ('' instanceof String) === false ("නූලක් නූල් නොවේ")

බව සටහන Object.getPrototypeOfවැනි නඩුව වළක්වා ගැනීමට යොදා let v = { constructor: String };ඇති isTypeතවමත් නිවැරදිව නැවත කාර්යය isType(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');
}

• වලංගු කිරීම සඳහා සෑම විටම "සුදු ලැයිස්තු" භාවිතා කරන්න. ඔබට වටිනාකමක් අවශ්‍ය නම්, උදා: නූලක්, අංකයක් හෝ අරාවක්, එම “සුදු” හැකියාවන් 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) ...

  • "අයිතමයක් නොමැති අරාව": if (isType(val, Array) && val.length === 0) ...

  • එකම ව්‍යතිරේකය වන්නේ nullයම් ක්‍රියාකාරීත්වයක් දැක්වීමට භාවිතා කරන විටය . මෙම අවස්ථාවේ දී කීම අර්ථවත් ය: "රික්ත අගයක්":if (val === null) ...

විවිධ තර්කනයන් සමඟ උත්සාහ කරන්න . වලංගු කිරීම සඳහා ඔබට බෙලෝ කේතය භාවිතා කළ හැකිය (4) වලංගු නොවන, හිස් නොවූ, නිර්වචනය නොකළ සහ ශුන්‍ය නොවීම වැනි ජාවාස්ක්‍රිප්ට් සහ 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 coalescing operator දෙස බලන්න

මෙම අංගය - ??ක්‍රියාකරු - සමඟ ගනුදෙනු කිරීමේදී nullහෝ පෙරනිමි අගයකට “ආපසු වැටීමේ” ක්‍රමයක් ලෙස ඔබට සිතිය හැකිය undefined.

let x = foo ?? bar();

නැවතත්, ඉහත කේතය පහත සඳහන් දේට සමාන වේ.

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

function isEmpty(val){
    return !val;
}

නමුත් මෙම විසඳුම ඕනෑවට වඩා සැලසුම් කර ඇති අතර, පසුව කාර්යබහුල-ආකෘති අවශ්‍යතා සඳහා ශ්‍රිතය වෙනස් කිරීමට ඔබට අවශ්‍ය නැතිනම්, එය කෙලින්ම කේතයෙන් භාවිතා කිරීම වඩා පිරිසිදු ය:

if(!val)...

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

මෙය කිසි විටෙකත් දෝෂයක් ඇති නොකරනු ඇත. නම් myObject , ළමා , හෝ myValue NULL වේ නම් 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;
    }
}

ඔබ සියලු සුදු අවකාශයේ නූල් ("") පරීක්ෂා කිරීමට කැමති නම්, ඔබට පහත සඳහන් දෑ කළ හැකිය:

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

සටහන: hasOwnPropertyවිචල්‍යය ඒවායින් එකක් ලෙස ප්‍රකාශයට පත් කර ඇත්නම්, හිස් නූල්, 0, අසත්‍ය, NaN, ශුන්‍ය සහ නිර්වචනය නොකළ සත්‍ය සඳහා ප්‍රතිලාභ ලබා දෙයි, එබැවින් එය භාවිතා කිරීමට හොඳම නොවේ. එය ප්‍රකාශයට පත් කළ බව පෙන්වීමට එය භාවිතා කිරීම සඳහා ශ්‍රිතය වෙනස් කළ හැකි නමුත් එය භාවිතා කළ නොහැක.

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

පරීක්ෂණ ප්‍රති results ල:

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")) {

ගූගල් පරිවර්තන ශ්‍රිතය 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;

කිසිවක් සොයාගත නොහැකි වූ විට පෙරනිමි අගයක් ගොඩනගා ගැනීම සඳහා විකල්ප දම්වැලෙන් පසු ශුන්‍ය සිසිලන ක්‍රියාකරු භාවිතා කළ හැකිය:

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

බොහෝ විට කෙටිම පිළිතුර නම්

val==null || val==''

ඔබ දෘඩ පැත්ත වෙනස් කළහොත් val===''හිස් අරාව අසත්‍ය වේ. සාක්ෂි

function isEmpty(val){
    return val==null || val==''
}

// ------------
// TEST
// ------------

var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" - so we should get here TRUE

පිළිබඳ වැඩි විස්තර ==( මෙහි මූලාශ්‍රය )

බෝනස් : හේතුව ===වඩා පැහැදිලි වන්නේ ඇයි==

පැහැදිලි සහ පහසුවෙන් තේරුම්ගත හැකි කේතයක් ලිවීමට, පිළිගත් අගයන් පිළිබඳ පැහැදිලි ලැයිස්තුවක් භාවිතා කරන්න

val===undefined || val===null || val===''|| (Array.isArray(val) && val.length===0)

function isEmpty(val){
    return val===undefined || val===null || val==='' || (Array.isArray(val) && val.length===0)
}

// ------------
// TEST
// ------------

var log = (name,val) => console.log(`${name} -> ${isEmpty(val)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" - so we should get here TRUE

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

එය පහත සඳහන් දෑ සමඟ සුදු අවකාශයන් ('') ද පරීක්ෂා කරනු ඇත:

• null, undefined, NaN, හිස්, නූල් (""), 0, අසත්ය