Как я могу проверить наличие пустой / неопределенной / нулевой строки

Как я могу проверить наличие пустой / неопределенной / нулевой строки в JavaScript?

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

Показать лучший ответ

просто к вашему сведению, я думаю, что самые полезные API-интерфейсы для класса String находятся в Mozilla и javascript kit . [elated.com] ( elated.com/articles/working-with-strings) содержит руководство по всем свойствам, методам String ... Обратите внимание: ссылка Mozilla была обновлена ​​до developer.mozilla.org/en/JavaScript/Reference/Global_Objects‌ /…

Было бы очень полезно, если бы требование было четко указано. Для каких значений isEmpty должен возвращать true? Проверка на "" предполагает, что он должен возвращать истину только в том случае, если значение - строка типа и длина 0. Многие ответы здесь предполагают, что он также должен возвращать истину для некоторых или всех ложных значений.

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

if (strValue) {
    //do something
}
 

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

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

Проверка свойства length может быть быстрее, чем проверка строки на "", потому что интерпретатору не нужно будет создавать объект String из строкового литерала.

@Vincent выполняет наивное профилирование в инструментах разработчика Chrome, тестирование === '' vs .length не показало заметных улучшений (а использование .length работает только в том случае, если вы можете предположить что у вас есть строка)

@bdukes, когда вы начинаете заботиться о таких микрооптимизациях, я не думаю, что Chrome - это браузер, в котором у вас возникают большинство проблем с производительностью ...

Отметим, что если ваше определение «пустой строки» включает пробелы, то это решение не подходит. Строка из 1 или более пробелов выше возвращает истину. Если вы используете JQuery, вы можете просто использовать это: if ($ .trim (ref) .length === 0) - согласно этому ответу на аналогичный вопрос: stackoverflow. ru / questions / 2031085 /…

@Chad, Ваш jsPerf довольно ошибочен, поскольку один из тестов сравнивает конкретное значение, а другой сравнивает любое значение, кроме пустого. Итак, чтобы было справедливо, первый тест должен быть s!=="" , что «всего» на 24% медленнее, чем s.length > 0

Поскольку он отличается от каждой версии Chrome, правильный способ - написать его так, чтобы он определял, какая версия Chrome находится в каком списке, и использовал самый быстрый метод: P Вы потратите больше циклов, проверяя, какую версию Chrome вы используете и который самый быстрый. Честно говоря, в последнее время это так близко к сравнению, просто выберите тот вкус, который вам больше всего подходит. Не проверять длину хорошо для некоторых способностей типа утки. Хотя все знают об опасности уток и должны использовать TypeScript; факт ™.

@ kir.gera, JavaScript не выдает ошибок компиляции, вы получаете эту ошибку от компилятора TypeScript? Если вашему компилятору требуется строгое значение bool , вы можете Boolean(u.GroupRole) или !!u.GroupRole

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

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

Плохая идея. Вы получите истинное значение, если strVar случайно присвоит 0.

Если не определено, проверка не выполняется. Итак, если (str) работает лучше

@ValentinHeinitz, если str было присвоено ложное значение 0 или «0», если (str) неверно сообщит true. Лучший подход - if (str === ""). Это просто и никогда не подведет.

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

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

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

if (!str.length) { ...
 

Разве это не вызовет исключение, если str имеет значение null?

@PicMickael Да! Так и str.Empty .

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

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

Но сработает, если вы действительно хотите проверить строку с непространственным содержимым. Есть ли менее дорогой способ проверить это?

Как насчет свойства длины?

Вместо того, чтобы удалять все пробелы, почему бы просто не проверить, нет ли пробелов? Имеет 2 преимущества: он может выйти из строя раньше, если есть непробельный символ, и он не возвращает новую строку, которую вы затем проверяете. if(str.match(/\S/g)){}

@Mark FYI, вам не понадобится глобальный модификатор, поскольку совпадение первого вхождения непробельного символа означало бы, что строка не пуста: str.match(/\S/)

почему дорого? Если это так, то почему jQuery использует этот метод? Вы можете найти это в исходном коде jQuery var trimLeft = /^\s+/, trimRight = /\s+$/;

+1 Я попробовал этот метод, и он у меня сработал. Пользователь может ввести пробелы, которые все еще остаются пустыми.

if(str.replace(/^\s+|\s+$/g,"")){...}+ будет достаточно

Почему бы вам просто не использовать if(str.trim()) {...} ?

Возможно, /\S/.test(str) лучше, чем str.match(/\S/) , потому что он не заботится о возврате массива совпадающих результатов (может быть, здесь наблюдается микропроизводительность). Кроме того, когда вы просто тестируете строку на соответствие регулярному выражению, используйте метод RegExp .test() , чтобы лучше передать это намерение.

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

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

Оператор == не является строгим. Итак, если str == "" , str может быть null , undefined , false , 0 , [] и т. д.

Аватар Jet

Я использую:

 function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case typeof(e) == "undefined":
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
})) // false
  

Это решение больше не зависит от языка. Единственная функция JavaScript, на которую он полагается, - это typeof. Таким образом, это хороший пример решения, которое вы можете использовать, когда не доверяете реализациям в разных браузерах и у вас нет времени найти лучшее решение. (IE, нет доступа в Интернет). Это что-то вроде доказательства. Не самый чистый, но вы можете быть уверены, что он будет работать, даже не слишком разбираясь в JavaScript.

Я бы пошел еще немного дальше и прибил его с помощью оператора === для неопределенного случая. В противном случае это просто идеальный ответ.

typeof в switch у меня не работал. Я добавил тест if (typeof e == "undefined") , и он работает. Зачем?

@Lucas Потому что это была опечатка или недосмотр. Ваша модификация - это правильный подход. (оригинал относится к контексту пустой функции, а не к параметру e, который функция должна проверять)

Можно ли использовать case undefined: вместо case typeof(e) == "undefined": ?

Попробуй

str.value.length == 0
 

"".value.length вызовет ошибку. Это должно быть str.length === 0

Это означает, что TypeError Если str равно undefined или null

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

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

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

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

Просто интересно, не могли бы вы объяснить, когда потребуется проверка длины? Разве! PString не поймает ничего, что является пустой строкой? Кажется, это работает. var test = ''; если (! test) alert ('пусто');

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

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

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

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

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

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

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

Интересный анализ. Не думаю, что это будет актуально в 99,9% случаев. НО недавно я обнаружил, что MySQL оценивает столбец как «нулевой», если (и только если) этот столбец содержит нулевой символ («\ 0»). Oracle, с другой стороны, не будет оценивать «\ 0» как нулевое, предпочитая рассматривать его как строку длиной 1 (где этот один символ является нулевым символом). Это может вызвать путаницу, если с ней не работать должным образом, потому что многие веб-разработчики действительно работают с серверной базой данных, которая может передавать различные типы "нулевых" значений. Это должно быть в памяти каждого разработчика.

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

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

TestMe();

var str = 'hello';

TestMe();
 

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

Попробуйте:

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

Требуется ли свойство длины?

str.trim().length будет работать быстрее, чем str.trim() , примерно на 1% согласно результатам моего собственного тестирования.

OP пытается проверить наличие пустой строки, неопределенного или нулевого значения. Это проверка строки, которая не соответствует ни одному из этих условий. Он также ничего не сказал о строках, содержащих только пробелы. Вы можете проверить условия OP, если уверены, что в переменной не хранятся другие типы данных: if (!str) { ... }

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

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

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

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

А? Если вы ожидаете строку, empty(0) и empty(7) должны возвращать одно и то же значение.

В моем конкретном случае - empty("0") должен возвращать false (потому что это не пустая строка), но empty(0) должен возвращать true , потому что он пустой :)

Но 0 не пусто! Это число, которое не может быть полным или пустым. Конечно, это ваша функция и поэтому она должна удовлетворять вашим требованиям, но в данном случае имя empty вводит в заблуждение.

Я думаю, что имя empty хорошее. В документации php для функции пустой : Returns FALSE if var exists and has a non-empty, non-zero value. Otherwise returns TRUE. Разница между PHP и этой функцией - эта строка '0' не будет идентифицироваться как пустая.

Как я уже сказал, это ваша функция: называйте это как хотите. Но empty - неточное и вводящее в заблуждение имя. Интересно, что в PHP также есть функция empty с плохим именем, но ошибки PHP не имеют ничего общего с JavaScript.

Аватар JHM

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

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

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

Существуют более сложные примеры, но они просты и дают стабильные результаты. Нет необходимости проверять undefined, поскольку он включен в проверку (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 JavaScript
    ['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 (s === "").

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

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

Вводить отрицание в имена функций - плохая идея. Сам код в порядке, но функцию следует называть как-то вроде hasValue (). Зачем? Что происходит, когда вы видите такой код: «if (! IsNotBlank (str))» ... Не сразу понятно, каково должно быть намерение. Это может показаться вам неуместным для этого простого примера, но добавление отрицания к имени функции всегда плохая идея.

IsNotBlank - стандартная функция и очень популярная функция в StringUtils commons.apache.org/proper/commons-lang/apidocs/org/apache/…

он также предоставляет IsBlank, чтобы избежать двойного отрицания. Я считаю, что имена функций должны отражать выполняемую ими функциональность, и разработчикам было бы легче понять, когда они увидят функции isBlank и IsNotBlank в одном классе.

Аватар Kev

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

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

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

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


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

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

if (!str.length) {
    // Do something
}
 

Самый быстрый, если вы знаете, что переменная является строкой. Выдает ошибку, если переменная не определена.

@ AdrianHope-Bailie, зачем вам тестировать неопределенную переменную?

@AbimaelMartell Почему бы и нет? У вас есть переменная, которую вы объявили или передали вам из некоторой области, которую вы не можете контролировать, например, в ответе от метода или вызова API. Вы можете предположить, что он содержит значение, и использовать проверку выше, но если он не определен или имеет значение null, вы получите сообщение об ошибке. var test = null; if (! test.length) {alert ("Адриан ошибается");}

OP спрашивал, «как проверить наличие пустой строки», переменная un undefined не является пустой строкой. В любом случае вы можете проверить typeof variable != "undefined" , прежде чем проверять, пуст ли.

Функция:

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 ;

-1 Тестируют по разному. Нет смысла объединять их все в один оператор if .

typeof MyVariable == 'undefined' не делает различий между инициализированной переменной с неопределенным значением и необъявленной переменной, если переменная не была изначально объявлена ​​и инициализирована значением null. Проверка свойства length приводит к тому, что строковый примитив будет заключен в строковый объект.

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

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

     let undefinedStr;
    if (!undefinedStr) {
      console.log("String is undefined");
    }
    
    let emptyStr = "";
    if (!emptyStr) {
      console.log("String is empty");
    }
    
    let nullStr = null;
    if (!nullStr) {
      console.log("String is null");
    }  

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

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

Неправильно. length не является null . str = ''; str.length == 0 не str.length == null . Но в целом ваш подход нормальный.

Проверка свойства length приведет к тому, что строковый примитив будет заключен в строковый объект, а проверка на null также неверна, поскольку он не ищет undefined (что не одно и то же). Чтобы проверить наличие пустой строки, просто сравните ее с "" (т.е. if (myString === ""))

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

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

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

  1. убедитесь, что var a; существует
  2. обрезать false spaces в значении, затем проверить наличие emptiness

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

<html>
    <head>
        <script lang="javascript">

            function nullcheck()
            {
                var n = "fdgdfg";
                var e = n.length;
                if (e == 0)
                {
                    return true;
                }
                else
                {
                    alert("success");
                    return false;
                }
            }
        </script>
    </head>

    <body>
        <button type="submit" value="add" onclick="nullcheck()"></button>
    </body>
</html>
 

Объяснение было бы в порядке.

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

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

<цитата>

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

_.isEmpty([1, 2, 3]);
=> ложь

_.isEmpty({});
=> верно

Другие очень полезные функции Underscore.js включают:

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

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

Я знаю, что это немного чрезмерно.

Проверка на неопределенность должна быть перемещена на первое место в проверках, иначе неопределенные элементы будут вызывать исключения при предыдущих проверках.

Полностью согласен! ХОРОШО ПОЙМАЛ. Я отредактирую свой ответ выше!

str.length === 0 возвращает истину для любой функции, не имеющей формальных параметров.

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

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

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

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

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

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

if(!val)...
 

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

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

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

_.isEmpty(" "); // => false

@Erich Потому что " " не пуст. _.isEmpty(""); возвращает истину.

Совершенно верно - я упомянул об этом, потому что некоторые из других ответов здесь подразумевают проверку формы и проверку того, состоит ли строка только из пробелов, и эта единственная функция lodash сама по себе не решит эту проблему.

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

Какая польза от использования !(!!this.length) , а не просто !this (или !this.trim() для второго варианта)? Строка нулевой длины уже является фальшивой, круглые скобки избыточны, и трижды отрицать ее - это то же самое, что отрицать ее один раз.

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

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

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

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

// considering the variable in which your string is saved is named str.

if (str && str.length>0) { 

  // Your code here which you want to run if the string is not empty.

}
 

Используя это, вы также можете убедиться, что строка также не является неопределенной или нулевой. Помните, что undefined, null и empty - это три разные вещи.

Это вызовет ошибку при null или undefined, потому что мы не должны напрямую выполнять операцию с переменной, которая имеет значение null или undefined - проверьте, существует ли str, прежде чем делать это, как указано в других ответах, а также обратите внимание, что это будет работать на let abc = '' но не на let abc = '', это разные.

Рассмотрим let rand = ()=>Math.random() , тогда rand && rand.length > 0) возвращает false, но очевидно, что fn не является "пустым". Т.е. он возвращает false для любой функции, не имеющей параметров формата.

@RobG Math.random() возвращает число, а не строку. И этот ответ касается струн. ;-)

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

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

Следующее регулярное выражение - еще одно решение, которое можно использовать для пустой, пустой или неопределенной строки.

(/(null|undefined|^$)/).test(null)
 

Я добавил это решение, потому что его можно расширить, чтобы проверить пустое значение или какое-либо значение, как показано ниже. Следующее регулярное выражение проверяет, может ли строка быть пустой null undefined или содержать только целые числа.

(/(null|undefined|^$|^\d+$)/).test()
 

Я не нашел здесь хорошего ответа (по крайней мере, не подходящего для меня)

Поэтому я решил ответить сам:

value === undefined || value === null || value === "";

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

Не может быть !! или только if(value) , поскольку если вы отметите 0 , он даст вам ложный ответ (0 - ложь).

С учетом сказанного, оберните его таким способом:

public static isEmpty(value: any): boolean { return value === undefined || value === null || value === ""; }

PS: Вам не нужно проверять typeof , так как он взорвется и бросится еще до того, как войдет в метод

Вероятно, лучше использовать конструкцию Boolean (value), которая обрабатывает значения undefined и null (а также 0, -0, false, NaN) как false. См. stackoverflow.com/questions/856324/…

Проверьте все следующие сценарии:

  1. null

  2. неопределено

  3. 0

  4. "" (пустая строка)

  5. ложно

  6. NaN

Производительность

Я провожу тесты на macOS v10.13.6 (High Sierra) для 18 выбранных решений. Решения работают немного по-другому (для входных данных в крайнем случае), что было представлено во фрагменте ниже.

<▪ Выводы

  • простые решения, основанные на !str ,==,=== и length , быстры для всех браузеров (A, B, C , G, I, J)
  • решения, основанные на регулярном выражении (test , replace ) и charAt , самые медленные для всех браузеров (H, L, M, P)
  • Решения, отмеченные как самые быстрые, были самыми быстрыми только в одном тестовом прогоне, но во многих прогонах оно меняется внутри группы «быстрых» решений.

 Введите здесь описание изображения

Подробности

В приведенном ниже фрагменте я сравниваю результаты выбранных 18 методов, используя разные входные параметры

  • "" "a" " " - пустая строка, строка с буквой и строка с пробелом.
  • [] {} f - массив, объект и функция
  • 0 1 NaN Infinity - числа
  • true false - логический
  • null undefined

Не все протестированные методы поддерживают все варианты ввода.

 function A(str) {
  let r=1;
  if (!str)
    r=0;
  return r;
}

function B(str) {
  let r=1;
  if (str == "")
    r=0;
  return r;
}

function C(str) {
  let r=1;
  if (str === "")
    r=0;
  return r;
}

function D(str) {
  let r=1;
  if(!str || 0 === str.length)
    r=0;
  return r;
}

function E(str) {
  let r=1;
  if(!str || /^\s*$/.test(str))
    r=0;
  return r;
}

function F(str) {
  let r=1;
  if(!Boolean(str))
    r=0;
  return r;
}

function G(str) {
  let r=1;
  if(! ((typeof str != 'undefined') && str) )
    r=0;
  return r;
}

function H(str) {
  let r=1;
  if(!/\S/.test(str))
    r=0;
  return r;
}

function I(str) {
  let r=1;
  if (!str.length)
    r=0;
  return r;
}

function J(str) {
  let r=1;
  if(str.length <= 0)
    r=0;
  return r;
}

function K(str) {
  let r=1;
  if(str.length === 0 || !str.trim())
    r=0;
  return r;
}

function L(str) {
  let r=1;
  if ( str.replace(/\s/g,"") == "")
    r=0;
  return r;
}

function M(str) {
  let r=1;
  if((/^\s*$/).test(str))
    r=0;
  return r;
}


function N(str) {
  let r=1;
  if(!str || !str.trim().length)
    r=0;
  return r;
}

function O(str) {
  let r=1;
  if(!str || !str.trim())
    r=0;
  return r;
}

function P(str) {
  let r=1;
  if(!str.charAt(0))
    r=0;
  return r;
}

function Q(str) {
  let r=1;
  if(!str || (str.trim()==''))
    r=0;
  return r;
}

function R(str) {
  let r=1;
  if (typeof str == 'undefined' ||
      !str ||
      str.length === 0 ||
      str === "" ||
      !/[^\s]/.test(str) ||
      /^\s*$/.test(str) ||
      str.replace(/\s/g,"") === "")

    r=0;
  return r;
}




// --- TEST ---

console.log(                  '   ""  "a"  " " [] {} 0 1 NaN Infinity f true false null undefined ');
let log1 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}     ${f(null)}    ${f(undefined)}`);
let log2 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}   ${f([])}  ${f({})}  ${f(0)} ${f(1)} ${f(NaN)}   ${f(Infinity)}        ${f(f)} ${f(true)}    ${f(false)}`);
let log3 = (s,f)=> console.log(`${s}: ${f("")}   ${f("a")}    ${f(" ")}`);

log1('A', A);
log1('B', B);
log1('C', C);
log1('D', D);
log1('E', E);
log1('F', F);
log1('G', G);
log1('H', H);

log2('I', I);
log2('J', J);

log3('K', K);
log3('L', L);
log3('M', M);
log3('N', N);
log3('O', O);
log3('P', P);
log3('Q', Q);
log3('R', R);  

Затем для всех методов я провожу тест скорости str = "" для браузеров Chrome v78.0.0, Safari v13.0.4 и Firefox v71.0.0 - вы можете запускать тесты на своем компьютере здесь

 Введите здесь описание изображения

Это действительно здорово! Мне нравится видеть все это выложенным! Спасибо!