JavaScript에서 null, 정의되지 않음 또는 공백 변수를 확인하는 표준 함수가 있습니까?

질문자 :Alex

undefined 되지 않았거나 null 이 아닌지 확인하는 범용 JavaScript 함수가 있습니까? 이 코드가 있지만 모든 경우에 적용되는지 확실하지 않습니다.

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

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

 if( value ) { }

value 이 다음 이 아닌 경우 true 평가됩니다.

• 없는
• 찾으시는 주소가 없습니다
• 난
• 빈 문자열("")
• 0
• 거짓

위의 목록은 ECMA-/Javascript에서 falsy ToBoolean 섹션 의 사양 에서 찾으십시오.

또한 변수가 있는지 여부를 모르는 경우(즉, 선언된 경우 typeof 연산자로 확인해야 합니다. 예를 들어

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

적어도 변수 가 선언된 것을 확신할 수 있다면 위와 같이 truthy 이 있는지 직접 확인해야 합니다.

jAndy

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

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

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

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

Salman A

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

이것은 true를 반환합니다.

 undefined // Because undefined == null null [] ""

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

후자의 범주를 허용하지 않으려면 빈 문자열만 확인하는 것이 좋습니다.

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

Mike Samuel

이것은 가장 안전한 수표이며 여기에 정확히 다음과 같이 게시된 것을 보지 못했습니다.

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

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

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

_{편집됨: 지금은 표준이기 때문에 완전 평등(!==)으로 변경됨 ;)}

guya

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

 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(strawman) 제안입니다." – 사이먼 켈버그. 저자는 왕의 즉위를 위한 이 아름다운 제안에 대한 지원을 추가하고자 합니다.

Vix

가장 좋은 평가를 받은 첫 번째 답변은 잘못되었습니다. 값이 정의되지 않은 경우 최신 브라우저에서 예외가 발생합니다. 다음을 사용해야 합니다.

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

또는

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

krupar

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

빈 변수가 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) ) }

보고:

• true: undefined , null , "" , [] , {}
• 거짓: true , false , 1 , 0 , -1 , "foo" , [1, 2, 3] , { foo: 1 }

Alexandre Magro

이 상태 확인

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

필요한 모든 것입니다.

JerryP

! 빈 문자열(""), null, undefined, false, 숫자 0 및 NaN을 확인합니다. 예를 들어 문자열이 비어 있으면 var name = "" console.log(!name) 가 true 반환합니다.

 function isEmpty(val){ return !val; }

이 함수는 val 이 비어 있거나 null, 정의되지 않음, false, 숫자 0 또는 NaN 이면 true를 반환합니다.

또는

!val 또는 !!val 과 같이 사용할 수 있습니다.

Arif

당신은 그것을 조금 과시하고 있습니다. 변수에 값이 주어지지 않았는지 확인하려면 undefined와 null만 확인하면 됩니다.

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

이것은 0 , "" 및 개체(빈 개체 및 배열 포함)가 유효한 "값"이라고 가정합니다.

tcooc

새로운 ECMAScript Nullish 병합 연산자 살펴보기

당신은이 기능을 생각할 수 있습니다 - ?? null 또는 undefined 처리할 때 기본값으로 "대체"하는 방법입니다.

 let x = foo ?? bar();

다시 말하지만, 위의 코드는 다음과 동일합니다.

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

Daniel Delgado

여기 내 것이 있습니다 - 값이 null, 정의되지 않은 등이거나 비어 있는 경우(즉, 공백만 포함된 경우) true를 반환합니다.

 function stringIsEmpty(value) { return value ? value.trim().length == 0 : true; }

DavidWainwright

일반 자바 스크립트를 선호하는 경우 다음을 시도하십시오.

 /** * 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)

l3x

공허함

전 세계의 값이 비어 있는지 여부를 계산하는 함수를 정의하거나 사용하지 않는 것이 좋습니다. "비어있다"는 것은 실제로 무엇을 의미합니까? 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 는 모두 "거짓"입니다. 덜 자연스럽게, 숫자 0 NaN 제외한 다른 숫자 없음)도 "거짓"입니다. 최소한 자연스럽게: '' 는 거짓이지만 [] 및 {} (및 new Set() 및 new Map() )은 사실입니다. 모두 똑같이 공허해 보이지만!

---

Null 대 정의되지 않음

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

• null 아닌 undefined 가 지정된 경우에만 기본값을 받습니다.

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

나에게 null 은 공허함의 명시적 기표입니다. "채울 수 있는 내용을 의도적으로 비워 두었습니다."

정말 undefined 것은 일부 js 기능이 존재하도록 허용하는 필수 합병증이지만 제 생각 에는 항상 뒤에 남겨두어야 합니다. 와 직접 상호 작용하지 않습니다 . 예를 들어, 기본 함수 인수를 구현하기 위한 자바스크립트 메커니즘 undefined 를 생각할 수 있습니다. 함수에 인수를 제공하지 않으면 undefined 값을 받게 됩니다. undefined 설정된 경우 기본값이 함수 인수에 적용됩니다. 이 경우 undefined 는 기본 함수 인수의 핵심이지만 배경에 남아 있습니다. undefined

undefined 와 직접 상호 작용하기 때문에 기본 인수의 잘못된 구현입니다.

 let fnWithDefaults = arg => { if (arg === undefined) arg = 'default'; ... };

이것은 좋은 구현입니다:

 let fnWithDefaults = (arg='default') => { ... };

이것은 기본 인수를 받아들이는 나쁜 방법입니다.

 fnWithDefaults(undefined);

대신 다음을 수행하십시오.

 fnWithDefaults();

---

일반적이지 않은 진공도

나는 공허함을 결코 일반적인 방식으로 다루어서는 안 된다고 생각합니다. 대신 항상 데이터가 비어 있는지 여부를 결정하기 전에 데이터에 대한 더 많은 정보를 얻기 위해 엄격해야 합니다. 저는 주로 어떤 유형의 데이터를 처리하는지 확인하여 이 작업을 수행합니다.

 let isType = (value, Cls) => { // Intentional use of loose comparison operator detects `null` // and `undefined`, and nothing else! return value != null && Object.getPrototypeOf(value).constructor === Cls; };

이 함수는 다형성을 무시하는 것으로 -가 기대 value 직접 인스턴스로 Cls 아닌 서브 클래스의 인스턴스 Cls . 나는 두 가지 주요 이유로 instanceof

• ([] instanceof Object) === true ("배열은 개체입니다")
• ('' instanceof String) === false ("문자열은 문자열이 아닙니다")

Object.getPrototypeOf 는 let v = { constructor: String }; isType isType(v, String) (false) 및 isType(v, Object) (true)에 대해 올바르게 반환합니다.

전반적으로 다음 팁과 함께 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 값이 통과하지 못하도록 하는 데 유용하지만 값 이 통과하더라도 우리는 여전히 그것에 대해 거의 알지 못합니다. 이 null-check를 통과하는 값 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 이 특정 기능을 나타내는 데 사용되는 경우입니다. 이 경우 "A vacuous value": if (val === null) ...

Gershy

return val || 'Handle empty variable'

많은 곳에서 그것을 처리하는 정말 훌륭하고 깨끗한 방법이며 변수를 할당하는 데에도 사용할 수 있습니다.

 const res = val || 'default value'

cubefox

변수가 선언되지 않은 경우 오류가 발생하기 때문에 함수를 사용하여 정의되지 않은 항목을 테스트할 수 없습니다.

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

foo가 선언되지 않은 경우 둘 다 오류를 생성합니다.

변수가 선언되었는지 테스트하려면 다음을 사용할 수 있습니다.

 typeof foo != "undefined"

foo가 선언되었고 사용할 수 있는 값이 있는지 테스트하려는 경우

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

herostwist

아마도 가장 짧은 대답은

 val==null || val==''

오른쪽을 val==='' 로 변경하면 빈 배열이 false를 제공합니다. 증거

 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

Kamil Kiełczewski

기본값을 확인하려면

 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()을 사용하여 어떤 유형의 객체를 확인했습니다.

인스턴스 사용 «

 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]"

Yash

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 }

jales cardoso

유용할 수 있습니다.

배열의 모든 값은 원하는 값(null, undefined 또는 기타 항목)을 나타내며 원하는 값을 검색합니다.

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

ddagsan

TypeScript 를 사용 하고 있고 "값이 false 값"을 설명하고 싶지 않다면 이것이 당신을 위한 솔루션입니다:

첫 번째: import { isNullOrUndefined } from 'util';

그런 다음: isNullOrUndefined(this.yourVariableName)

참고: 아래에 언급된 것처럼 이것은 이제 더 이상 사용되지 않습니다. value === undefined || value === null 대신 null입니다. 참조

BlackBeard

다른 논리로 시도하십시오 . null이 아닌, 공백이 아닌, 정의되지 않은 및 0이 아닌 것과 같은 유효성 검사를 위해 네(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); } }

Ravikant

nullish 병합 연산자를 사용할 수 있습니까 ?? null 및 undefined 값을 확인합니다. MDN 문서 보기

 null ?? 'default string'; // returns "default string" 0 ?? 42; // returns 0 (null || undefined) ?? "foo"; // returns "foo"

thenewjames

function isEmpty(val){ return !val; }

그러나 이 솔루션은 과도하게 설계되었습니다. 나중에 비즈니스 모델 요구 사항에 따라 함수를 수정하지 않으려면 코드에서 직접 사용하는 것이 더 깔끔합니다.

 if(!val)...

Luca C.

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

이것은 결코 오류를 던지지 않을 것입니다. myObject , child 또는 myValue 가 null이면 myNewValue 는 null이 됩니다. 오류가 발생하지 않습니다.

Keith Blanchard

비슷한 질문을 가지고 여기 오는 모든 사람들에게 다음은 훌륭하게 작동하며 지난 몇 년 동안 내 라이브러리에 있습니다.

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

centurian

jAndy의 답변 에 따르면 값이 다음 중 하나인 경우 true가 되는 것을 피하려면 다음을 수행하십시오.

• 없는
• 찾으시는 주소가 없습니다
• 난
• 빈 문자열("")
• 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를 반환하므로 사용하는 것이 가장 좋지 않을 수 있습니다. 선언되었지만 사용할 수 없음을 표시하기 위해 함수를 수정하여 사용할 수 있습니다.

yaserso

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]

Pascal Polleunus

선택적 연결 연산자는 참조 또는 함수가 정의되지 않았거나 null일 수 있는 경우 연결된 개체를 통해 값에 액세스하는 것을 단순화하는 방법을 제공합니다.

 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

Sunny Sultan

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

다음과 함께 공백(' ')도 검사합니다.

• null , 정의되지 않음 , NaN , 비어 있음 , 문자열("") ,0 , false

Hassan Ali Shahzad

출처 : http:www.stackoverflow.com/questions/5515310/is-there-a-standard-function-to-check-for-null-undefined-or-blank-variables-in