변수가 그렇지 않은하는 가치와 보장하지만이 수표를 가지고있는 보편적 인 자바 스크립트 기능이 있습니까 undefined또는 null? 이 코드가 있지만 모든 경우에 해당되는지 확실하지 않습니다.

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

변수 에 truthy값 이 있는지 여부를 확인할 수 있습니다 . 그 의미는

if( value ) {
}

로 평가됩니다 true경우 value입니다 하지 :

• 없는
• 찾으시는 주소가 없습니다
• NaN
• 빈 문자열 ( "")
• 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

값이 정의되지 않았거나 null인지 확인하는 자세한 방법은 다음과 같습니다.

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

==연산자를 사용할 수도 있지만 모든 규칙 을 알고 있어야합니다 .

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

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

이것은에 대한 true를 반환합니다

undefined  // Because undefined == null

null

[]

""

함수 length는 선언 된 매개 변수의 수 이므로 인수 함수 가 없습니다.

후자의 범주를 허용하지 않으려면 빈 문자열 만 확인하면됩니다.

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

이것은 가장 안전한 검사이며 여기에 정확하게 게시 된 것을 보지 못했습니다.

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

값 이 정의되지 않은 경우 와 다음 중 하나 를 다룹니다 .

• 없는
• undefined (정의되지 않은 값은 정의되지 않은 매개 변수와 동일하지 않음)
• 0
• ""(빈 문자열)
• 그릇된
• NaN

_{편집 : 엄격한 평등 (! ==)으로 변경되었습니다. 지금은 표준이기 때문입니다.)}

다음 기능이 유용 할 수 있습니다.

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
}

당신이 필요한 전부입니다.

! 확인 빈 문자열 ( "") 널 (null), 정의되지 않은 허위 숫자 0과 NaN가. 문자열이 비어 var name = ""있으면를 console.log(!name)반환합니다 true.

function isEmpty(val){
  return !val;
}

이 함수는 val 이 비어 있거나 null, undefined, false, 숫자 0 또는 NaN 인 경우 true를 반환합니다 .

또는

문제 도메인에 따르면 !val또는 처럼 사용할 수 있습니다 !!val.

내가 많이 좋아하는 솔루션 :

빈 변수가 null, 또는 undefined길이이거나 길이가 0이거나 객체 인 경우 키가없는 것으로 정의 해 보겠습니다 .

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 }

당신은 그것을 약간 과장하고 있습니다. 변수에 값이 제공되지 않았는지 확인하려면 undefined 및 null 만 확인하면됩니다.

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)

여기에 광산이 있습니다-value가 null, undefined 등이거나 공백 인 경우 true를 반환합니다 (예 : 공백 만 포함).

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에서 :

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 ])-이 목록은 그래서 그 자체가 비워 목록입니다, 공허함이 들어? 자바 스크립트에서 "vacuousness"(기존의 연관성을 피하기 위해 의도적으로 모호한 단어)에 대한 몇 가지 참고 사항을 제시하고자합니다. 그리고 자바 스크립트 값의 "vacuousness"는 일반적으로 처리되지 않아야한다고 주장하고 싶습니다.

진실 / 거짓

값의 "빈도"를 결정하는 방법을 결정하려면 값이 "거실"인지 "거짓"인지에 대한 자바 스크립트의 내장 된 고유 한 의미를 수용해야합니다. 당연히, null그리고 undefined모두 "falsy"입니다. 덜 자연스럽게, 숫자 0(및 다른 숫자는 제외 NaN)도 "거짓"입니다. 가장 자연스럽게 : ''허위이지만 [], 그리고 {}(그리고 new Set(), 그리고 new Map())는 진실합니다 – 비록 모두 공허하게 보입니다!

널 대 정의되지 않음

관련된 논의도있다 null대 undefined우리가 정말 우리의 프로그램에서 vacuousness을 표현하기 위해 모두 필요합니까는? - 나는 개인적으로 문자 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직접 인스턴스 일 것으로 예상 됩니다 . 두 가지 주요 이유로 피 합니다.ClsClsinstanceof

• ([] instanceof Object) === true ( "배열은 객체이다")
• ('' 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');
}

• 유효성 검사를 위해 항상 "화이트리스트"를 사용하십시오. 예를 들어 문자열, 숫자 또는 배열과 같은 값이 필요한 경우 이러한 "백색"가능성을 확인하고 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) ...
  • "0보다 작거나 같은 숫자": if (isType(val, Number) && val <= 0) ...

  • "항목이없는 배열": if (isType(val, Array) && val.length === 0) ...

  • 유일한 null기능은 특정 기능을 나타내는 데 사용되는 경우 입니다. 이 경우 다음과 같이 말하는 것이 의미가 있습니다. "빈 값":if (val === null) ...

다른 논리로 시도하십시오 . 자바 스크립트와 jquery에서 null이 아니고, 비어 있지 않고, 정의되지 않았으며 0이 아닌이 코드 (! (! (variable))) 만 사용하는 것과 같이 유효성 검사를 위해 four (4) 조건을 모두 확인하기 위해 다음 코드를 사용할 수 있습니다.

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 통합 연산자를 살펴보십시오

이 기능 생각할 수 - ??연산자 - 기본 값을 "가을 다시"에 대한 방법을 다룰 때 같이 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는 null가됩니다. 오류가 발생하지 않습니다

비슷한 질문을하기 위해 여기에 오는 모든 사람들에게 다음은 훌륭하게 작동하며 지난 몇 년 동안 내 도서관에 있습니다.

(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의 답변 에 따라 값이 다음 중 하나 인 경우 true를 피하려면 :

• 없는
• 찾으시는 주소가 없습니다
• NaN
• 빈 문자열 ( "")
• 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!
}

이러한 시나리오 외에도 객체 또는 배열 이 비어 있으면 false를 반환 할 수 있습니다 .

• 개체 : {} ( 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, false, NaN, null 및 undefined에 대해 true를 반환하므로 사용하기에 가장 적합하지 않을 수 있습니다. 함수가 선언되었음을 나타 내기 위해 함수를 수정할 수 있지만 사용할 수는 없습니다.

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

위의 구글 번역 함수 TranslateElement가 존재하는지 확인합니다. 이것은 다음과 같습니다.

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

선택적 연결 연산자를 사용하면 참조 또는 함수가 정의되지 않았거나 null 일 수있는 경우 연결된 개체를 통해 값에 쉽게 액세스 할 수 있습니다.

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

null이없는 병합 연산자는 옵션 체인이 없으면 기본값이없는 경우 기본값을 만들기 위해 사용할 수 있습니다.

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, 거짓

나는? 작업자가 약간 더 깨끗합니다.

var ? function_if_exists() : function_if_doesnt_exist();