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

Question

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

Answer 1

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

if (strValue) {
    //do something
}

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

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

Answer 2

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

Answer 3

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

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

или используйте приведение типов:

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

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

Answer 4

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

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

Answer 5

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

if (!str.length) { ...

Answer 6

Я использую :

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

Answer 7

Попробуй:

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

Answer 8

Функция:

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

p.s.В Javascript не используйте Разрыв строки после return;

Answer 9

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

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

Answer 10

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

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

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

Answer 11

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

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

Answer 12

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

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

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

Answer 13

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

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

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

Answer 14

1. проверьте это var a; существовать

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

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

Answer 15

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

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

Answer 16

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

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

Answer 17

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

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

Answer 18

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

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

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

Answer 19

Все эти ответы приятны.

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

Answer 20

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

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

Answer 21

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

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

Answer 22

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

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

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

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

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

Answer 23

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

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

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

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

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

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

Answer 24

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

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

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

if(!val)...

Answer 25

Между тем у нас может быть одна функция, которая проверяет наличие всех "пустых" объектов, например null, не определено, ", ' ', {}, [].Поэтому я просто написал это.

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

Answer 26

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

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

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

Answer 27

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

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

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

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

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 === '')
  ...

Answer 28

Попробуй это

str.value.length == 0

Answer 29

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

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

В противном случае, если вы хотите проверить оба варианта '' пустая строка и ' ' с помощью space вы можете сделать это, просто добавив trim(), что - то вроде приведенного ниже кода:

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

и вы можете назвать это так:

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

Answer 30

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

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