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

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

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

для проверки, является ли строка пустой, пустой или неопределенной я использую:

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

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

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

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

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

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

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

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

попробуй:

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

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

редактировать: за комментарий от Константин, если бы strVar мог каким-то образом содержать целое значение 0, то это действительно было бы одной из тех ситуаций, проясняющих намерение.

функция:

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

можно использовать лодашь : _.пустой(значения).

он охватывает много случаев, как {},'',null,undefined etc.

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

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

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

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

1. проверяем, что

2. обрезать false spaces в значении, а затем проверить на emptiness

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

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

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

немного чрезмерно, я знаю.

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

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

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

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

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

var y = ""; // 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(/^[]*$/)); 
}
...
"".isNull() // true

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

вы не хотите помещать его в прототип строк, потому что если экземпляр класса 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; } }]
];

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

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

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

if(!val)...

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

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

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

попробуй такое

   str.value.length == 0

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

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

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

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

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

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