JavaScript에서 비어 있거나 정의되지 않은 / 널 문자열을 확인하려면 어떻게해야합니까?

내가 본 이 질문에 ,하지만 난 자바 스크립트 구체적인 예제를 참조하지 않았다. string.EmptyJavaScript로 제공 되는 간단한 것이 ""있습니까? 아니면 확인하는 경우 입니까?

어떤 가치가 있는지 확인하고 싶다면 할 수 있습니다

if (strValue) {
    //do something
}

당신이 널 (null)를 통해 빈 문자열을 위해 특별히 확인해야 할 경우, 나는에 대하여 확인하는 것은 생각 ""하여, 당신의 최선의 방법이다 연산자를 (당신은, 사실, 문자열은 당신이에 대해 비교하고 그것이 알고 그래서).===

if (strValue === "") {
    //...
}

문자열이 비어 있는지, null인지 또는 정의되지 않았는지 확인하려면 다음을 사용하십시오.

function isEmpty(str) {
    return (!str || 0 === str.length);
}

문자열이 비어 있는지, null인지 또는 정의되지 않았는지 확인하려면 다음을 사용하십시오.

function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

문자열이 비어 있거나 공백 만 포함되어 있는지 확인하려면 다음을 수행하십시오.

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};

이전의 모든 대답은 좋지만 더 좋습니다. !!( 아님 ) 연산자를 사용하십시오 .

if(!!str){
    // Some code here
}

또는 유형 캐스팅을 사용하십시오.

if(Boolean(str)){
    // Code here
}

둘 다 동일한 기능을 수행합니다. 변수를 부울로 타입 캐스트합니다 str. 여기서 변수는입니다.
를 반환 false합니다 null,undefined,0,000,"",false. 문자열 "0"및 공백 ""을
반환 true합니다.

str.Emptystr이 String이라는 전제 조건으로 얻을 수있는 가장 가까운 것은 다음 과 같습니다.

if (!str.length) { ...

문자열이 단지 빈 공간이 아닌지 확인 해야하는 경우 (이것은 양식 유효성 검사라고 가정합니다) 공백을 바꿔야합니다.

if(str.replace(/\s/g,"") == ""){
}

나는 사용한다:

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case typeof(e) == "undefined":
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
})) // false

lodash : _.isEmpty (value)를 사용할 수 있습니다 .

이 같은 경우를 많이 다루고 {}, '', null, undefined, 등

그러나 그것은 항상 반환 true을위한 Number유형의 자바 스크립트 기본 데이터 형 과 같은 _.isEmpty(10)또는 _.isEmpty(Number.MAX_VALUE)모두 돌아갑니다 true.

함수:

function is_empty(x)
{
    return (
        (typeof x == 'undefined')
                    ||
        (x == null)
                    ||
        (x == false)  //same as: !x
                    ||
        (x.length == 0)
                    ||
        (x == "")
                    ||
        (x.replace(/\s/g,"") == "")
                    ||
        (!/[^\s]/.test(x))
                    ||
        (/^\s*$/.test(x))
    );
}

추신 : JavaScript에서는 줄 바꿈을 사용하지 마십시오 return.

시험:

if (str && str.trim().length) {  
    //...
}

var s; // undefined
var s = ""; // ""
s.length // 0

JavaScript에는 빈 문자열을 나타내는 것이 없습니다. 중 하나에 대해 검사를 수행합니다 length(당신이 VAR는 항상 문자열이 될 것을 알고 경우)에 대한""

가장 효율적인 방법 에 대해 너무 걱정하지 않아도됩니다 . 가장 명확한 것을 사용하십시오. 나를 위해 그것은 일반적으로 strVar == ""입니다.

Constantin 의 의견에 따르면 strVar가 정수 0 값을 포함하는 방법이 있다면 의도를 명확히하는 상황 중 하나 일 것입니다.

많은 답변과 다양한 가능성!

빠르고 간단한 구현에 대한 의심의 여지가없는 승자는 다음과 같습니다. if (!str.length) {...}

그러나 다른 많은 예가 있습니다. 이에 대한 가장 좋은 기능적 방법은 다음과 같습니다.

function empty(str)
{
    if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "")
    {
        return true;
    }
    else
    {
        return false;
    }
}

조금 과도합니다.

정규식을 사용할 수도 있습니다.

if((/^\s*$/).test(str)) { }

비어 있거나 공백으로 채워진 문자열을 확인합니다.

1. var a;존재 하는지 확인

2. false spaces값을 잘라 내고emptiness

   if ((a)&&(a.trim()!=''))
   {
     // if variable a is not empty do this 
   }

공연

18 개의 선택된 솔루션에 대해 macOS v10.13.6 (High Sierra)에서 테스트를 수행 합니다. 솔루션은 아래 스 니펫에 표시된 약간 다른 (코너 케이스 입력 데이터의 경우) 작동합니다.

결론

• 간단한 솔루션에 기초하여 !str, ==, ===및 length모든 브라우저 빠르다 (A, B, C, G, I, J)
• 정규식 ( test, replace)을 기반으로하며 charAt모든 브라우저 (H, L, M, P)에서 가장 느린 솔루션
• 가장 빠른 것으로 표시된 솔루션은 한 번의 테스트 실행에 대해서만 가장 빠르지 만 많은 실행에서 '빠른'솔루션 그룹 내에서 변경됩니다.

세부

아래 스 니펫에서는 다른 입력 매개 변수를 사용하여 선택한 18 가지 방법의 결과를 비교합니다

• "" "a" " "-빈 문자열, 문자가있는 문자열 및 공백이있는 문자열
• [] {} f-배열, 객체 및 함수
• 0 1 NaN Infinity - 번호
• true false -부울
• null undefined

모든 테스트 방법이 모든 입력 사례를 지원하는 것은 아닙니다.

function A(str) {
  let r=1;
  if (!str)
    r=0;
  return r;
}

function B(str) {
  let r=1;
  if (str == "")
    r=0;
  return r;
}

function C(str) {
  let r=1;
  if (str === "")
    r=0;
  return r;
}

function D(str) {
  let r=1;
  if(!str || 0 === str.length)
    r=0;
  return r;
}

function E(str) {
  let r=1;
  if(!str || /^\s*$/.test(str))
    r=0;
  return r;
}

function F(str) {
  let r=1;
  if(!Boolean(str))
    r=0;
  return r;
}

function G(str) {
  let r=1;
  if(! ((typeof str != 'undefined') && str) )
    r=0;
  return r;
}

function H(str) {
  let r=1;
  if(!/\S/.test(str))
    r=0;
  return r;
}

function I(str) {
  let r=1;
  if (!str.length)
    r=0;
  return r;
}

function J(str) {
  let r=1;
  if(str.length <= 0)
    r=0;
  return r;
}

function K(str) {
  let r=1;
  if(str.length === 0 || !str.trim())
    r=0;
  return r;
}

function L(str) {
  let r=1;
  if ( str.replace(/\s/g,"") == "")
    r=0;
  return r;
}

function M(str) {
  let r=1;
  if((/^\s*$/).test(str))
    r=0;
  return r;
}


function N(str) {
  let r=1;
  if(!str || !str.trim().length)
    r=0;
  return r;
}

function O(str) {
  let r=1;
  if(!str || !str.trim())
    r=0;
  return r;
}

function P(str) {
  let r=1;
  if(!str.charAt(0))
    r=0;
  return r;
}

function Q(str) {
  let r=1;
  if(!str || (str.trim()==''))
    r=0;
  return r;
}

function R(str) {
  let r=1;
  if (typeof str == 'undefined' ||
      !str ||
      str.length === 0 ||
      str === "" ||
      !/[^\s]/.test(str) ||
      /^\s*$/.test(str) ||
      str.replace(/\s/g,"") === "")

    r=0;
  return r;
}




// --- TEST ---

console.log(                  '   ""  "a"  " " [] {} 0 1 NaN Infinity f true false null undefined ');
let log1 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}     ${f(null)}    ${f(undefined)}`);
let log2 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}`);
let log3 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}`);

log1('A', A);
log1('B', B);
log1('C', C);
log1('D', D);
log1('E', E);
log1('F', F);
log1('G', G);
log1('H', H);

log2('I', I);
log2('J', J);

log3('K', K);
log3('L', L);
log3('M', M);
log3('N', N);
log3('O', O);
log3('P', P);
log3('Q', Q);
log3('R', R);

그런 다음 모든 방법에 str = ""대해 브라우저 Chrome v78.0.0, Safari v13.0.4 및 Firefox v71.0.0에 대한 속도 테스트 사례 를 수행 합니다. 여기에서 컴퓨터 에서 테스트를 실행할 수 있습니다

또한 공백으로 채워진 문자열을 "빈"것으로 간주하는 경우.

이 정규식으로 테스트 할 수 있습니다.

!/\S/.test(string); // Returns true if blank.

나는 보통 이런 식으로 사용합니다.

if (!str.length) {
    // Do something
}

문자열에 null 문자가있을 가능성을 고려한 답변을 보지 못했습니다. 예를 들어, 널 문자열이있는 경우 :

var y = "\0"; // an empty string, but has a null character
(y === "") // false, testing against an empty string does not work
(y.length === 0) // false
(y) // true, this is also not expected
(y.match(/^[\s]*$/)) // false, again not wanted

Null을 테스트하기 위해 다음과 같이 할 수 있습니다.

String.prototype.isNull = function(){ 
  return Boolean(this.match(/^[\0]*$/)); 
}
...
"\0".isNull() // true

null 문자열과 빈 문자열에서 작동하며 모든 문자열에 액세스 할 수 있습니다. 또한 다른 JavaScript 공백 또는 공백 문자 (예 : 비 분리 공백, 바이트 순서 표시, 줄 / 단자 구분자 등)를 포함하도록 확장 할 수 있습니다.

한편 우리는 null, undefined, '', '', {}, [] 와 같은 모든 '빈'을 확인하는 하나의 함수를 가질 수 있습니다 . 그래서 나는 이것을 썼습니다.

var isEmpty = function(data) {
    if(typeof(data) === 'object'){
        if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
            return true;
        }else if(!data){
            return true;
        }
        return false;
    }else if(typeof(data) === 'string'){
        if(!data.trim()){
            return true;
        }
        return false;
    }else if(typeof(data) === 'undefined'){
        return true;
    }else{
        return false;
    }
}

사용 사례 및 결과.

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false

현재 문자열이 비어 있는지 여부를 확인하는 string.empty와 같은 직접적인 방법은 없습니다. 그러나 코드에서 다음과 같은 빈 문자열에 대해 래퍼 검사를 사용할 수 있습니다.

// considering the variable in which your string is saved is named str.

if (str && str.length>0) { 

  // Your code here which you want to run if the string is not empty.

}

이를 사용하여 문자열이 정의되지 않았거나 null이 아닌지 확인할 수도 있습니다. undefined, null 및 empty는 서로 다른 세 가지입니다.

이 모든 대답은 훌륭합니다.

그러나 변수가 문자열이고 공백 만 포함하지 않으며 (나에게 중요 함) '0'(문자열)을 포함 할 수 있는지 확신 할 수 없습니다.

내 버전 :

function empty(str){
    return !str || !/[^\s]+/.test(str);
}

empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty("  "); // true

jsfiddle의 샘플 .

나는 여기에 좋은 대답을 보지 못했습니다 (적어도 나에게 맞는 대답은 아닙니다)

그래서 나는 스스로 대답하기로 결정했습니다.

value === undefined || value === null || value === "";

정의되어 있지 않은지 확인해야합니다. 그렇지 않으면 메소드가 폭발 할 수 있으며 null 또는 빈 문자열과 같은지 확인할 수 있습니다.

당신은 가질 수 없습니다! 또는 if(value)확인한 후에 만0 하면 거짓 답변을 제공하기 때문에 (0은 거짓).

그런 말로 다음과 같은 방법으로 마무리하십시오.

public static isEmpty(value: any): boolean { return value === undefined || value === null || value === ""; }

추신 : typeof 확인하지 않아도 메소드에 들어가기 전에 폭발하고 던질 수 있기 때문에

빈 문자열뿐만 아니라 빈 문자열도 감지해야하는 경우 Goral의 답변에 추가하겠습니다.

function isEmpty(s){
    return !s.length;    
}

function isBlank(s){
    return isEmpty(s.trim());    
}

이 시도

str.value.length == 0

JavaScript 로 네이티브 String 객체에 쉽게 추가하고 반복해서 재사용 할 수 있습니다 . 빈 문자열 을 확인하려면 아래 코드와 같은 간단한 작업을 수행하면 됩니다.
''

String.prototype.isEmpty = String.prototype.isEmpty || function() {
  return !(!!this.length);
}

그렇지 않으면 ''빈 문자열과 ' '공백이 모두 있는지 확인하려면 trim()아래 코드와 같이을 추가하면 됩니다.

String.prototype.isEmpty = String.prototype.isEmpty || function() {
   return !(!!this.trim().length);
}

그리고 당신은 이것을 다음과 같이 부를 수 있습니다 :

''.isEmpty(); //return true
'alireza'.isEmpty(); //return false

이 시도:

export const isEmpty = string => (!string || !string.length);

문자열이 아니고 비어 있거나 널이 아닌 값을 테스터 함수에 전달하면 어떻게되는지 조사했습니다. 많은 사람들이 알고 있듯이 JavaScript에서는 (0 == "")가 true이지만 0은 값이거나 비어 있거나 null이 아니므로 테스트 할 수 있습니다.

다음 두 함수는 정의되지 않은 null, 빈 / 공백 값에 대해서만 true를 반환하고 숫자, 부울, 객체, 표현식 등과 같은 다른 모든 항목에 대해서는 false를 반환합니다.

function IsNullOrEmpty(value)
{
    return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
    return (value == null || !/\S/.test(value));
}

더 복잡한 예가 존재하지만 간단하고 일관된 결과를 제공합니다. 정의되지 않은 테스트는 (value == null) 검사에 포함되어 있으므로 테스트 할 필요가 없습니다. 다음 과 같이 C # 동작을 String에 추가하여 C # 동작을 모방 할 수도 있습니다 .

String.IsNullOrEmpty = function (value) { ... }

String 클래스의 인스턴스가 null이면 오류가 발생하기 때문에 Strings 프로토 타입에 넣지 않으려합니다.

String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // Could be set
myvar.IsNullOrEmpty(); // Throws error

다음 값 배열로 테스트했습니다. 의심스러운 경우 기능을 테스트하기 위해 반복 할 수 있습니다.

// Helper items
var MyClass = function (b) { this.a = "Hello World!"; this.b = b; };
MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
var z;
var arr = [
// 0: Explanation for printing, 1: actual value
    ['undefined', undefined],
    ['(var) z', z],
    ['null', null],
    ['empty', ''],
    ['space', ' '],
    ['tab', '\t'],
    ['newline', '\n'],
    ['carriage return', '\r'],
    ['"\\r\\n"', '\r\n'],
    ['"\\n\\r"', '\n\r'],
    ['" \\t \\n "', ' \t \n '],
    ['" txt \\t test \\n"', ' txt \t test \n'],
    ['"txt"', "txt"],
    ['"undefined"', 'undefined'],
    ['"null"', 'null'],
    ['"0"', '0'],
    ['"1"', '1'],
    ['"1.5"', '1.5'],
    ['"1,5"', '1,5'], // Valid number in some locales, not in JavaScript
    ['comma', ','],
    ['dot', '.'],
    ['".5"', '.5'],
    ['0', 0],
    ['0.0', 0.0],
    ['1', 1],
    ['1.5', 1.5],
    ['NaN', NaN],
    ['/\S/', /\S/],
    ['true', true],
    ['false', false],
    ['function, returns true', function () { return true; } ],
    ['function, returns false', function () { return false; } ],
    ['function, returns null', function () { return null; } ],
    ['function, returns string', function () { return "test"; } ],
    ['function, returns undefined', function () { } ],
    ['MyClass', MyClass],
    ['new MyClass', new MyClass()],
    ['empty object', {}],
    ['non-empty object', { a: "a", match: "bogus", test: "bogus"}],
    ['object with toString: string', { a: "a", match: "bogus", test: "bogus", toString: function () { return "test"; } }],
    ['object with toString: null', { a: "a", match: "bogus", test: "bogus", toString: function () { return null; } }]
];

빈 문자열인지 확인하려면 :

if(val==="")...

빈 문자열인지 또는 값이없는 논리 값 (null, undefined, 0, NaN, false 등)인지 확인하려면 다음을 수행하십시오.

if(!val)...

방법이 없으므로 isEmpty()유형과 길이를 확인해야합니다.

if (typeof test === 'string' && test.length === 0){
  ...

testis undefined또는 일 때 런타임 오류를 피하려면 유형 검사가 필요합니다 null.

공백 문자열을 무시하면 null, 비어 있고 정의되지 않은 것을 확인할 수 있습니다.

var obj = {};
(!!obj.str) // Returns false

obj.str = "";
(!!obj.str) // Returns false

obj.str = null;
(!!obj.str) // Returns false

간결하고 정의되지 않은 속성에 대해 작동하지만 가장 읽기 쉽지는 않습니다.