Как вы проверяете пустую строку в JavaScript?

Я видел этот поток , но я не видел конкретного примера JavaScript. Есть ли простой string.Empty доступный в JavaScript, или это просто проверка "" ?

вопрос задан 30.09.2008
casademora
28718 репутация

39 ответов


  • 2788 рейтинг

    Если вы просто хотите проверить, есть ли какая-либо ценность, вы можете сделать

     if (strValue) {
        //do something
    }
     

    Если вам нужно специально проверить пустую строку с нулевым значением, я думаю, что проверка против "" - это лучший выбор, используя оператор === (чтобы вы знали, что это, по сути, строка, с которой вы сравниваете).

     if (strValue === "") {
        //...
    }
     
    ответ дан bdukes, с репутацией 110390, 30.09.2008
  • 914 рейтинг

    Для проверки, является ли строка пустой, null или undefined, я использую:

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

    Для проверки пустой строки, null или undefined, я использую:

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

    Для проверки, является ли строка пустой или содержит только пробел:

     String.prototype.isEmpty = function() {
        return (this.length === 0 || !this.trim());
    };
     
    ответ дан Jano González, с репутацией 9530, 16.07.2010
  • 232 рейтинг

    Все вышеизложенное хорошо, но это будет еще лучше. используйте оператор !! ( не ).

     if(!!str){
    some code here;
    }
     

    или использовать тип литья:

     if(Boolean(str)){
        codes here;
    }
     

    Оба выполняют ту же функцию, тип переводит переменную в boolean, где str - переменная.
    Возвращает false для null,undefined,0,000,"",false .
    Возвращает true для строки «0» и пробелов «».

    ответ дан karthick.sk, с репутацией 2337, 30.03.2011
  • 89 рейтинг

    Если вам нужно убедиться, что строка - это не просто пустая пустота (я предполагаю, что это для проверки формы), вам нужно сделать замену в пробелах.

     if(str.replace(/\s/g,"") == ""){
    }
     
    ответ дан Sugendran, с репутацией 1803, 30.09.2008
  • 78 рейтинг

    Самое близкое, что вы можете получить до str.Empty (с предварительным условием, что str является строкой):

     if (!str.length) { ...
     
    ответ дан Ates Goral, с репутацией 98975, 30.09.2008
  • 46 рейтинг

    Я использую :

     function empty(e) {
      switch (e) {
        case "":
        case 0:
        case "0":
        case null:
        case false:
        case typeof this == "undefined":
          return true;
        default:
          return false;
      }
    }
    
    empty(null) // true
    empty(0) // true
    empty(7) // false
    empty("") // true
    empty((function() {
        return ""
      })) // false
     
    ответ дан Jet, с репутацией 913, 9.07.2010
  • 24 рейтинг
     var s; // undefined
    var s = ""; // ""
    s.length // 0
     

    В JavaScript нет ничего, представляющего пустую строку. Сделайте проверку против length (если вы знаете, что var всегда будет строкой) или против ""

    ответ дан roosteronacid, с репутацией 13124, 30.09.2008
  • 23 рейтинг

    Пытаться:

     if (str && str.trim().length) {  
        //...
    }
     
    ответ дан Yang Dong, с репутацией 284, 9.01.2013
  • 22 рейтинг

    Я бы не стал слишком беспокоиться о самом эффективном методе. Используйте то, что наиболее ясно для вашего намерения. Для меня это обычно strVar == "" .

    РЕДАКТИРОВАТЬ: за комментарий от Константина , если strVar может каким-то образом в конечном итоге содержать целочисленное значение 0, то это действительно будет одной из тех ситуаций, которые уточняют намерения.

    ответ дан Chris Noe, с репутацией 17636, 30.09.2008
  • 21 рейтинг

    Функция:

     function Is_Empty_or_Undefined (MyVar)
    {
       return 
       ( 
            (typeof MyVar== 'undefined')
                        ||
            (MyVar == null) 
                        ||
            (MyVar == false)  //same as: !MyVariable
                        ||
            (MyVar.length == 0)
                        ||
            (MyVar == "")
                        ||
            (MyVar.replace(/\s/g,"") == "")
                        ||
            (!/[^\s]/.test(MyVar))
                        ||
            (/^\s*$/.test(MyVar))
      );
    }
     
    ответ дан T.Todua, с репутацией 26766, 27.02.2014
  • 18 рейтинг

    Вы можете использовать lodash : _.isEmpty (значение).

    Он охватывает множество случаев, таких как {} , '' , null , undefined и т. Д.

    Но он всегда возвращает true для Number типов примитивных типов данных Javascript, таких как _.isEmpty(10) или _.isEmpty(Number.MAX_VALUE) и возвращает true .

    ответ дан Moshii, с репутацией 538, 17.08.2017
  • 17 рейтинг

    вы также можете использовать регулярные выражения:

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

    Проверяет строки, которые либо пусты, либо заполнены пробелами.

    ответ дан oem, с репутацией 171, 31.05.2010
  • 13 рейтинг
    1. проверьте, что var a; существует
    2. выровняйте false spaces в значении, затем проверьте на emptiness

       if ((a)&&(a.trim()!=''))
      {
        // if variable a is not empty do this 
      }
       
    ответ дан Timothy Nwanwene, с репутацией 476, 24.02.2015
  • 12 рейтинг

    Много ответов и много разных возможностей!

    Без сомнения, для быстрой и простой реализации победитель: 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;
        }
    } 

    Я знаю немного.

    ответ дан tfont, с репутацией 6258, 31.03.2016
  • 11 рейтинг

    Кроме того, если вы считаете заполненную пробелами строку «пустой». Вы можете проверить это с помощью этого регулярного выражения:

     !/\S/.test(string); // Returns true if blank.
     
    ответ дан Wab_Z, с репутацией 111, 15.05.2013
  • 10 рейтинг

    Обычно я использую что-то вроде этого,

     if (!str.length) {
    //do some thing
    }
     
    ответ дан user2086641, с репутацией 1951, 9.08.2013
  • 9 рейтинг

    Я не заметил ответа, который учитывает возможность пустых символов в строке. Например, если у нас есть строка с нулевым символом:

     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
     

    Чтобы проверить его нулевость, можно сделать что-то вроде этого:

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

    Он работает с пустой строкой и на пустой строке и доступен для всех строк. Кроме того, его можно было бы расширить, чтобы содержать другие пробелы JavaScript или пробельные символы (то есть неразрушающее пространство, отметку байтового байта, разделитель строк /абзацев и т. Д.).

    ответ дан Bikush, с репутацией 499, 31.07.2012
  • 8 рейтинг

    Если нужно обнаружить не только пустые, но и пустые строки, я добавлю к ответу Горала:

     function isEmpty(s){
        return !s.length;    
    }
    
    function isBlank(s){
        return isEmpty(s.trim());    
    }
     
    ответ дан Josef.B, с репутацией 564, 1.10.2014
  • 7 рейтинг

    Все эти ответы хороши.

    Но я не могу быть уверен, что переменная является строкой, не содержит только пробелов (это важно для меня) и может содержать «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 .

    ответ дан Andron, с репутацией 4539, 8.05.2013
  • 7 рейтинг

    Игнорируя строки с пробелами, вы можете использовать это для проверки пустых и неопределенных значений:

     var obj = {};
    (!!obj.str) //returns false
    
    obj.str = "";
    (!!obj.str) //returns false
    
    obj.str = null;
    (!!obj.str) //returns false
     

    Кратко, и он работает для неопределенных свойств, хотя это не самый читаемый.

    ответ дан mricci, с репутацией 460, 19.07.2012
  • 7 рейтинг

    Я использую комбинацию, сначала выполняются самые быстрые проверки.

     function isBlank(pString){
        if (!pString || pString.length == 0) {
            return true;
        }
        // checks for a non-white space character 
        // which I think [citation needed] is faster 
        // than removing all the whitespace and checking 
        // against an empty string
        return !/[^\s]+/.test(pString);
    }
     
    ответ дан Will, с репутацией 4326, 1.06.2011
  • 6 рейтинг

    чтобы проверить, является ли именно пустая строка:

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

    проверить, является ли она пустой строкой ИЛИ aa логическим эквивалентом для no-value (null, undefined, 0, NaN, false, ...):

     if(!val)...
     
    ответ дан Luca C., с репутацией 2885, 2.06.2017
  • 6 рейтинг

    Обычно я использую что-то вроде:

     if (str == "") {
         //Do Something
    }
    else {
         //Do Something Else
    }
     
    ответ дан jmc734, с репутацией 169, 15.02.2010
  • 6 рейтинг

    Я провел некоторое исследование, что произойдет, если вы передадите функцию нестрочного и непустого /нулевого значения в функцию тестера. Как известно многим, (0 == "") истинно в javascript, но поскольку 0 является значением, а не пустым или нулевым, вы можете проверить его.

    Следующие две функции возвращают true только для неопределенных значений, null, empty /whitespace и false для всего остального, таких как числа, логические, объекты, выражения и т. Д.

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

    Существуют более сложные примеры, но они просты и дают согласованные результаты. Нет необходимости проверять неопределенность, поскольку она включена в (значение == null). Вы также можете имитировать поведение C #, добавив их в String следующим образом:

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

    Вы не хотите ставить его в прототипе Strings, потому что если экземпляр String-класса имеет значение NULL, это будет ошибкой:

     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 js
        ['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; } }]
    ];
     
    ответ дан JHM, с репутацией 306, 14.05.2013
  • 5 рейтинг

    Между тем у нас может быть одна функция, которая проверяет все «пустые», как 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
     
    ответ дан Imran, с репутацией 1994, 12.03.2018
  • 5 рейтинг

    Нет метода isEmpty() , вам нужно проверить тип и длину:

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

    Проверка типа необходима, чтобы избежать ошибок времени выполнения, когда test равно undefined или null .

    ответ дан Agustí Sánchez, с репутацией 5087, 4.11.2016
  • 5 рейтинг

    Попробуй это

        str.value.length == 0
     
    ответ дан Doug, с репутацией 59, 22.07.2010
  • 4 рейтинг

    Не предполагайте, что переменная, которую вы проверяете, является строкой. Не предполагайте, что если этот var имеет длину, то это строка.

    Дело в том, что внимательно подумайте о том, что ваше приложение должно делать и может принять. Постройте что-нибудь крепкое.

    Если ваш метод /функция должен обрабатывать непустую строку, тогда проверьте, является ли аргумент пустой строкой и не выполняйте «трюк».

    В качестве примера чего-то, что взорвется, если вы будете следовать некоторым советам здесь не осторожно.

    
    var getLastChar = function (str) {
     if (str.length > 0)
       return str.charAt(str.length - 1)
    }
    
    getLastChar('hello')
    => "o"
    
    getLastChar([0,1,2,3])
    => TypeError: Object [object Array] has no method 'charAt'
     

    Итак, я придерживаюсь

    
    if (myVar === '')
      ...
     
    ответ дан Amida, с репутацией 1645, 15.07.2013
  • 4 рейтинг
     function tell()
    {
    var pass = document.getElementById('pasword').value;
    var plen = pass.length;
    
    now you can check if your string is empty as like 
    if(plen==0)
    {
             alert('empty');
    }
    else
    {
       alert('you entered something');
    }
    }
    
    
    <input type='text' id='pasword' />
     

    это также общий способ проверить, пусто ли поле.

    ответ дан Muhammad Salman, с репутацией 41, 6.08.2010
  • 3 рейтинг

    Вы можете проверить следующие способы и понять разницу.

     var j = undefined;
    console.log((typeof j == 'undefined') ? "true":"false");
    var j = null; 
    console.log((j == null) ? "true":"false");
    var j = "";
    console.log((!j) ? "true":"false");
    var j = "Hi";
    console.log((!j) ? "true":"false"); 

    ответ дан KARTHIKEYAN.A, с репутацией 4075, 30.11.2017
  • 3 рейтинг

    Вы также должны всегда проверять тип, так как JavaScript - это язык с утиным языком, поэтому вы можете не знать, когда и как данные изменились в середине процесса. Итак, вот лучшее решение:

     var str = "";
    if (str === "") {
        //...
    }
     
    ответ дан Sazid, с репутацией 1842, 6.05.2014
  • 3 рейтинг

    Библиотека javascript подчёркивания http://underscorejs.org/ предоставляет очень полезную функцию _.isEmpty() для проверки пустых строк и других пустых объектов.

    Ссылка: http://underscorejs.org/#isEmpty

    isEmpty _.isEmpty(object)
    Возвращает true, если перечисляемый объект не содержит значений (нет перечислимых собственных свойств). Для строк и объектов типа массива _.isEmpty проверяет, является ли свойство length равным 0.

    _.isEmpty([1, 2, 3]);
    => false

    _.isEmpty({});
    => true

    Другие очень полезные функции подчеркивания:
    http://underscorejs.org/#isNull _.isNull(object)
    http://underscorejs.org/#isUndefined _.isUndefined(value)
    http://underscorejs.org/#has _.has(object, key)

    ответ дан Thaddeus Albers, с репутацией 2542, 10.06.2015
  • 2 рейтинг

    Это также хорошая идея, чтобы проверить, что вы не пытаетесь передать неопределенный термин.

     function TestMe() {
      if((typeof str != 'undefined') && str) {
        alert(str);
      }
     };
    
    TestMe();
    
    var str = 'hello';
    
    TestMe();
     

    Я обычно сталкиваюсь с тем случаем, когда хочу что-то сделать, когда строковый атрибут для экземпляра объекта не пуст. Это прекрасно, за исключением того, что атрибут не всегда присутствует.

    ответ дан dkinzer, с репутацией 19278, 18.12.2012
  • 2 рейтинг

    Я предпочитаю использовать не пустой тест вместо пустого

     function isNotBlank(str) {
       return (str && /^\s*$/.test(str));
    }
     
    ответ дан Mubashar Ahmad, с репутацией 6859, 3.07.2013
  • 2 рейтинг

    Альтернативный способ, но я считаю, что лучший ответ bdukes.

        var myString = 'hello'; 
        if(myString.charAt(0)){
        alert('no empty');
        }
        alert('empty');
     
    ответ дан GibboK, с репутацией 32900, 10.02.2013
  • 1 рейтинг

    Вы можете легко добавить его в собственный объект String в JavaScript и повторно использовать его снова и снова ...
    Что-то простое, как ниже, код может выполнить эту работу для вас, если вы хотите проверить '' пустых строк:

     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
     
    ответ дан Alireza, с репутацией 39782, 7.10.2017
  • -3 рейтинг
    var x ="  ";
    var patt = /^\s*$/g;
    isBlank = patt.test(x);
    alert(isBlank);// is it blank or not??
    x=x.replace(/\s*/g,"");// another way of replacing blanks with ""
    if (x===""){alert("ya it is blank")}
    
    ответ дан Gaurav, с репутацией 463, 8.04.2014
  • -5 рейтинг
    <html>
    <head>
    <script lang="javascript">
    
    function nullcheck()
    {
    var n="fdgdfg";
    var e = n.length;
    if(e== 0)
    {
    
        return true;
    }
    else
    {
        alert("sucess");
        return false;
    }
    }
    
    
    </script>
    </head>
    <body>
    <button type="submit" value="add" onclick="nullcheck()"></button>
    </body>
    </html>
    
    ответ дан KanimozhiPalanisamy, с репутацией 41, 25.03.2015
  • -11 рейтинг

    Чтобы проверить, не пуст ли он:

     var str = "Hello World!";
    var n = str.length;
    if(n === ''){alert("THE STRING str is EMPTY");}
     

    Чтобы проверить, не является ли он пустым

     var str = "Hello World!";
    var n = str.length;
    if(n != ''){alert("THE STRING str isn't EMPTY");}
     
    ответ дан Alban Kaperi, с репутацией 110, 19.07.2014