Как проверить пустую / неопределенную / пустую строку в JavaScript?

Чтобы проверить, является ли строка пустой, 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());
};

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

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

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

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

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

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

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

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

if (!str.length) { ...

Я использую:

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

Функция:

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

ps В Javascript не используйте перевод строки после return;

Try:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

• проверьте, что var a; существует

• отредактируйте false spaces в значении, затем проверьте emptiness

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

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

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

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

if (!str.length) {
//do some thing
}

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

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

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

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

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

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

Но я не могу быть уверен, что переменная является строкой, не содержит только пробелов (это важно для меня) и может содержать '0' (string).

Моя версия:

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.

Между тем у нас может быть одна функция, которая проверяет все "пустые", как 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

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

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

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

if(!val)...

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

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

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

Существуют более сложные примеры, но они просты и дают согласованные результаты. Нет необходимости тестировать undefined, поскольку он включен в (value == null). Вы также можете имитировать поведение С#, добавив их в 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; } }]
];

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

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

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

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

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

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

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

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

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

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

Попробуй это

str.value.length == 0

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

if (str == "") {
     //Do Something
}
else {
     //Do Something Else
}

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

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

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

Библиотека javascript underscore 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)

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' />

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

Вы можете легко добавить его к собственному объекту 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

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

var str = "";
if (str === "") {
    //...
}

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

function isNotBlank(str) {
   return (str && /^\s*$/.test(str));
}

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

   var myString = 'hello'; 
    if(myString.charAt(0)){
    alert('no empty');
    }
    alert('empty');

Также неплохо проверить, что вы не пытаетесь передать термин undefined.

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

TestMe();

var str = 'hello';

TestMe();

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

Вы можете легко добавить его в собственный 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

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

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

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

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