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

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

ОТВЕТЫ

Ответ 1

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

if (strValue) {
    //do something
}

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

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

Ответ 2

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

Ответ 3

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

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

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

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

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

Ответ 4

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

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

Ответ 5

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

if (!str.length) { ...

Ответ 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

Ответ 7

Try:

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

Ответ 8

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

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

Ответ 9

Функция:

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;

Ответ 10

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

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

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

Ответ 11

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

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

Ответ 12

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

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

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

Ответ 13

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

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

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

Ответ 14

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

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

Ответ 15

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

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

Ответ 16

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

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

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

Ответ 18

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

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

Ответ 19

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

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

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

Ответ 20

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

Ответ 21

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

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

Ответ 22

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

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

Ответ 23

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

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

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

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

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

Ответ 24

Я провел некоторое исследование, что произойдет, если вы передадите функцию нестрочного и непустого/нулевого значения в функцию тестера. Как известно многим, (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; } }]
];

Ответ 25

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

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

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

if(!val)...

Ответ 26

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

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

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

Ответ 27

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

Ответ 28

Попробуй это:

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

Ответ 29

Попробуй это

str.value.length == 0

Ответ 30

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