Как я могу проверить наличие пустой / неопределенной / нулевой строки в JavaScript?
Я видел этот вопрос, но не видел конкретного примера JavaScript. Есть ли в JavaScript простой string.Empty или это просто проверка на ""?
Отметьте это: stackoverflow.com/a/36491147/7026966
Было бы очень полезно, если бы требование было четко указано. Для каких значений пусто должен возвращать истину? Проверка на "" означает, что он должен возвращать истину только в том случае, если значение - строка типа и длина 0. Многие ответы здесь предполагают, что он также должен возвращать истину для некоторых или всех ложных значений.
str.length> -1
![Безумие обратных вызовов в javascript [JS]](https://i.imgur.com/WsjO6zJb.png)
Ответы 52
Если вы просто хотите проверить, есть ли какое-либо значение, вы можете сделать
if (strValue) {
//do something
}
Если вам нужно специально проверить пустую строку над нулем, я бы подумал, что проверка на "" - ваш лучший выбор, используя оператор === (чтобы вы знали, что это, на самом деле, строка, с которой вы сравниваете).
if (strValue === "") {
//...
}
Проверка свойства length может быть быстрее, чем проверка строки на "", потому что интерпретатору не придется создавать объект String из строкового литерала.
@Vincent выполняет наивное профилирование в инструментах разработчика Chrome, тестирование === '' и .length не показало заметных улучшений (а использование .length работает только в том случае, если вы можете предположить, что у вас есть строка)
@bdukes, когда вы начинаете заботиться о таких микрооптимизациях, я не думаю, что Chrome - это браузер, в котором у вас возникают большинство проблем с производительностью ...
Обратите внимание: если ваше определение «пустой строки» включает пробелы, то это решение не подходит. Строка из 1 или более пробелов выше возвращает истину. Если вы используете JQuery, вы можете просто использовать это: if ($ .trim (ref) .length === 0) - согласно этому ответу на аналогичный вопрос: stackoverflow.com/questions/2031085/…
Как и ожидалось, .length > 0 на самом деле является намного быстрее, чем по сравнению со строковым литералом! Посмотрите этот jsPerf
@Chad, Ваш jsPerf довольно ошибочен, так как один из тестов сравнивает конкретное значение, а другой сравнивает любое значение, кроме пустого. Итак, чтобы было справедливо, первым тестом должен быть s!= = "", который «всего» на 24% медленнее, чем s.length > 0.
Поскольку он отличается от каждой версии Chrome, правильный способ - написать его так, чтобы он определял, какая версия Chrome находится в каком списке, и использовал самый быстрый метод: P Вы потратите больше циклов, проверяя, какую версию Chrome вы используете и который самый быстрый. Честно говоря, в последнее время это так близко к сравнению, просто выберите тот вкус, который вам больше всего подходит. Не проверять длину хорошо для некоторых способностей типа утки. Хотя все знают об опасности уток и должны использовать TypeScript; факт ™.
str = 0; если (строка) вернуть ложь
что, если нам нужно пройти эту проверку как lamda? f.e: if (users.some (u => u.GroupRole)) {} В этом случае есть ошибка компиляции, говорящая мне передать bool, а не строку
@ kir.gera, JavaScript не выдает ошибок компиляции, вы получаете эту ошибку от компилятора TypeScript? Если вашему компилятору требуется строгое значение bool, вы можете использовать Boolean(u.GroupRole) или !!u.GroupRole.
@casademora Это плохой ответ, потому что в некоторых ситуациях при запуске создается страница, инициализируемая null, а этот strValue === "" не работает. лучший синтаксис - !strValue GoodLuck
Прежде чем сосредоточиться на разнице в производительности, подумайте, сколько раз он будет запускаться. Например, если оператор «if» запускается один раз для каждого сайта, оптимизация производительности близка к нулю. и если ваш код длиннее оригинала, возможно, вы потеряете больше времени в сети, чем выиграете при выполнении javascript. И, наконец, когда вы используете какой-либо инструмент для сборки, эта микрооптимализация будет потеряна. Так что мой совет: «пишите более читаемый код».
Я бы не стал особо беспокоиться о самом методе эффективный. Используйте то, что наиболее ясно соответствует вашему намерению. Для меня это обычно strVar == "".
Согласно комментарию от Константин, если strVar может каким-то образом в конечном итоге содержать целочисленное значение 0, тогда это действительно будет одна из тех ситуаций, проясняющих намерение.
Плохая идея. Вы получите истину, если strVar случайно присвоит 0.
Я согласен с тем, что прояснение вашего намерения важнее, чем любые микрооптимизации, которые могут дать другие методы, но использование оператор строгого сравнения=== будет лучше. Он возвращает истину только в том случае, если strVar - пустая строка.
Если не определено, проверка не выполняется. Итак, если (str) работает лучше
@ValentinHeinitz, если str было присвоено ложное значение 0 или "0", если (str) ложно сообщит true. Лучший подход - if (str === ""). Это просто и никогда не подведет.
var s; // undefined
var s = ""; // ""
s.length // 0
В JavaScript нет ничего, что представляло бы пустую строку. Проверьте либо length (если вы знаете, что var всегда будет строкой), либо "".
Самое близкое, что вы можете получить к str.Empty (с предварительным условием, что str является String), это:
if (!str.length) { ...
Разве это не вызовет исключение, если строка имеет значение 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, [] и т. д.
Вы также можете использовать регулярные выражения:
if ((/^\s*$/).test(str)) { }
Проверяет строки, которые либо пусты, либо заполнены пробелами.
Это работает, но это ужасно дорого с точки зрения эксплуатации. Хорошо, если вы хотите просто проверить одну или две вещи, а не большой набор.
Я использую:
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":?
Для проверки того, является ли строка пустой, нулевой или неопределенной, я использую:
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());
};
почему 0 === str.length вместо str.length === 0?
Условия @Vincent часто записываются как if (variable == constant value), и если вы забыли знак «=», то вместо тестирования вы присваиваете переменной постоянное значение. Код по-прежнему будет работать, поскольку вы можете назначить переменную в if. Таким образом, более безопасный способ записать это условие - поменять местами постоянное значение и переменную. Таким образом, при тестировании кода вы увидите ошибку (недопустимая левая сторона в назначении). Вы также можете использовать что-то вроде JSHint, чтобы запретить присваивание в условиях и получать предупреждение, когда вы его напишете.
Я забыл упомянуть, что, поскольку вы в основном используете '===' или '! ==', вы меньше подвержены подобным ошибкам.
позор, что /^\s*$/.test(str) на самом деле не читается - может быть, лучше удалить пробелы с помощью более простого кода или регулярного выражения? см. stackoverflow.com/questions/6623231/…, а также stackoverflow.com/questions/10800355/…
Мне это нравится, и я добавил это в прототип String String.prototype.isEmpty = function () {return (! This || 0 === this.length); };
/^\s*$/.test(str) можно заменить на str.trim (). length === 0
@Vincent, это также называется «Условиями Йоды», например if blue is the sky. См. dodgycoder.net/2011/11/yoda-conditions-pokemon-exception.htm l
Чем return (this.length === 0 || !this.trim()) лучше, чем return !this.trim()?
@Jano Gonzales Почему бы в первой версии просто не использовать function isEmpty(str) { return !str; }?
На самом деле не стоит расширять собственные прототипы, как правило, считается плохой практикой, когда многие люди просто рекомендуют не делать этого полностью, поскольку есть более безопасные способы, которые не менее хороши. Существует обсуждение SO по теме здесь, но все книги по JS-программированию, которые я читал, настоятельно рекомендуют его не использовать. Для проблемы с OP я обычно просто делаю if (!str) { // i am sure str is empty null or undefined here if I'm sure it won't be another data type }
Попробуй это
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' />
Это также общий способ проверить, пусто ли поле.
Все предыдущие ответы хороши, но это будет еще лучше. Используйте операторы двойного НЕ (!!):
if (!!str) {
// Some code here
}
Или используйте приведение типов:
if (Boolean(str)) {
// Code here
}
Оба выполняют одну и ту же функцию. Приведите переменную к типу Boolean, где str - это переменная.
Он возвращает false для null, undefined, 0, 000, "", false.
Он возвращает true для строки "0" и пробела " ".
Почему это «даже лучше»?
Это неприятный трюк, это так, как надо. Это правильный путь. Javascript определяет истинность "" и null как ложь.
Есть ли разница между поведением if (str) и if (!!str)?
@PeterOlson, если вы пытаетесь сохранить переменную как логическое значение, которое проверяет несколько строк на предмет содержимого, тогда вы захотите сделать это .. иначе обработка var any = (!!str1 && !!str2 && !!str3), если там есть число
Я всегда использую это решение. !!str.trim(), чтобы убедиться, что строка не состоит только из пробелов.
Не похоже на хакерство, Boolean(str) намного более читабелен и менее "чокнутый".
@JohnRuddell Это не ответ на вопрос Питера, и это не похоже на то, что я хотел бы делать.
@xehpuk не уверен, что понимаю, что вы имеете в виду. оператор не не применяет логический тип .. также известный как истина или ложь. Если вы хотите принудительно использовать логический тип, используйте оператор not not. По сути, при проверке if между ними нет разницы. Но это особенно полезно, когда вам нужен логический флаг, который вы используете более чем в одном месте. Это то, о чем идет речь в моем комментарии, хотя это прямо не указано.
@JohnRuddell Да, поэтому этот ответ не очень полезен. А для логической переменной почему не var any = Boolean(str1 && str2 && str3);? Должно быть четче и быстрее.
@xehpuk нет, это совсем не быстрее. вы должны посмотреть, что делает Boolean
@JohnRuddell Boolean(value) преобразует любое значение в логическое значение. Простой. !! преобразует любое значение в логическое значение и дважды его инвертирует.
@xehpuk Вы не понимаете преимущества !!. Boolean - это класс javascript. У него есть множество методов. Когда вы используете Boolean как функцию, вы по-прежнему выделяете память для всех его методов, а также для его части базового класса. Это сложнее, чем простая логическая проверка оператора, поэтому !! более эффективен.
@xehpuk Boolean - это примитивный тип ... когда вы вызываете Boolean(something), вы вызываете функцию конструктора, которая соответствует примитивному типу Boolean ... (иначе говоря, без ключевого слова new), чтобы явно указать значение как правдивое или ложное (за исключением того, что оно возвращает логический объект, а не истинное логическое значение ... Если вы посмотрите на объявление MDN, что такое логическое значение, вы можете довольно легко увидеть, что он делает. но это в стороне ссылка, которая сравнивает скорость между Boolean и !!sitepoint.com/javascript-double-negation-trick-trouble
Обратите внимание, что !! не является оператором. Это один оператор, применяемый дважды.
Похоже на взлом
@Lluis Martinez, разборчивый, современный JS; было бы еще лучше, если бы OP написал: const someFunc = () => {}; !!str && someFunc()
Современный JS - несомненно. Разборчивость - дело вкуса. Для меня это не так :-)
!! Bang Bang, ты логический !!
@JohnRuddell, разве челка в var any = (!!str1 && !!str2 && !!str3) не избыточна? Не будет ли оператор && все равно преобразовывать операнды в логические?
@arth вы можете это сделать, это зависит от вашего стиля кода. Когда я выполняю логическую проверку, мне нравится приводить к bool через !!, чтобы обеспечить согласованное поведение ... когда вы не имеете дело с логическими значениями, реализация браузеров потенциально может вести себя иначе
@JohnRuddell Почему неявное преобразование переменной в логическое значение в браузере зависит от! оператор и оператор &&? .. а если да, то почему верить одному, а не другому?
@Arth @JohnRuddell: нет, челка не лишняя. Например, 'aa' && 'ddd' возвращает 'ddd', а не true. 'ddd' в дальнейшем оценивается как true, поэтому вы можете использовать только 'aa' && 'ddd' как есть в заявлении if. Но если вы присваиваете результат логическому значению, челка необходима.
@JohnRuddell @Arth: другими словами, && javascript не возвращает логическое значение, если только выбранный операнд не является логическим. Вот определение его поведения (для expr1 && expr2): «Если expr1 можно преобразовать в true, возвращает expr2; иначе возвращает expr1».
@AlvinThompson Ах да, я пропустил это .. спасибо, хороший момент! При назначении логической переменной необходимо явное преобразование, но вместо этого оно может быть выполнено как !!(str1 && str2 && str3) или Boolean(str1 && str2 && str3). Если не присваивать, явное преобразование излишне, достаточно if (str1 && str2 && str3){} ..
@JaredPrice Я не уверен в этом .. if (!!''){} и if (''){} должны давать одинаковый результат и эквивалентны в моих тестах на работоспособность на jsfiddle
Это хорошо, поскольку позволяет не использовать свойство .length, которое существует в Array и String.
@Mene Это лучше, потому что, если передается неопределенная переменная, возвращаемое значение будет undefined вместо логического false, а это короткое и легкое для понимания.
Это просто бесполезно в if, он преобразует ложные значения в false, а истинные значения в true. Блок if либо выполняется, либо не выполняется в зависимости от того, является ли выражение истинным, нет смысла добавлять !!.
Для тех, кому интересно: 1. Boolean(expr) - это то же самое, что и !!expr 2. Boolean(expr) внутри if бесполезен; if уже неявно приводит выражение, указанное внутри него. Это может стать неожиданностью, например, для тех, кто работает с C#.
Действительно аккуратно! Спасибо!
Я использую комбинацию, и в первую очередь идут самые быстрые проверки.
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, empty и undefined:
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 ищет пустую строку, undefined или null. Это проверка строки, которая не соответствует ни одному из этих условий. Он также ничего не сказал о строках с пробелами. Вы можете проверить условия 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.
Я провел некоторое исследование того, что произойдет, если вы передадите нестроковое и непустое / нулевое значение в функцию тестера. Как многие знают, (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). Вы также можете имитировать поведение 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 === "").
Также, если вы считаете строку, заполненную пробелами, «пустой».
Вы можете проверить это с помощью этого регулярного выражения:
!/\S/.test(string); // Returns true if blank.
Я предпочитаю использовать не пустой тест, а не пустой
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 в одном классе.
Не думайте, что проверяемая вами переменная является строкой. Не думайте, что если эта переменная имеет длину, то это строка.
Дело в том, что тщательно подумайте о том, что ваше приложение должно делать и может принять. Постройте что-нибудь надежное.
Если ваш метод / функция должен обрабатывать только непустую строку, проверьте, является ли аргумент непустой строкой, и не выполняйте никаких «трюков».
В качестве примера чего-то, что может взорваться, если вы не будете внимательно следовать некоторым советам.
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. Вы можете предположить, что он содержит значение, и использовать проверку выше, но если он не определен или равен нулю, вы получите сообщение об ошибке. var test = null; if (! test.length) {alert ("Адриан ошибается");}
OP спрашивал, «как проверить наличие пустой строки», переменная un undefined не является пустой строкой. В любом случае вы можете проверить typeof variable != "undefined", прежде чем проверять, пуст ли он.
Очень общая функция «все в одном» (не рекомендуется, хотя):
function is_empty(x)
{
return ( //don't put newline after return
(typeof x == 'undefined')
||
(x == null)
||
(x == false) //same as: !x
||
(x.length == 0)
||
(x == 0) // note this line, you might not need this.
||
(x == "")
||
(x.replace(/\s/g,"") == "")
||
(!/[^\s]/.test(x))
||
(/^\s*$/.test(x))
);
}
Однако я не рекомендую использовать это, потому что ваша целевая переменная должна быть определенного типа (например, строковая, числовая или объектная?), Поэтому применяйте проверки, относящиеся к этой переменной.
Есть ли шанс, что вы могли бы объяснить, что делает каждая проверка? :)
-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.info("String is undefined");
}
let emptyStr = "";
if (!emptyStr) {
console.info("String is empty");
}
let nullStr = null;
if (!nullStr) {
console.info("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());
}
- проверьте, что
var a;существует обрежьте
false spacesв значении, затем проверьтеemptinessif ((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>
Объяснение было бы в порядке.
Библиотека Underscore.js JavaScript, http://underscorejs.org/, предоставляет очень полезную функцию _.isEmpty() для проверки пустых строк и других пустых объектов.
Ссылка: http://underscorejs.org/#isEmpty
isEmpty
_.isEmpty(object)
Returns true if an enumerable object contains no values (no enumerable own-properties). For strings and array-like objects _.isEmpty checks if the length property is 0.
_.isEmpty([1, 2, 3]);
=> false
_.isEmpty({});
=> true
Другие очень полезные функции Underscore.js включают:
- http://underscorejs.org/#isNull
_.isNull(object) - http://underscorejs.org/#isUndefined
_.isUndefined(value)- http://underscorejs.org/#has
_.has(object, key)
Множество ответов и множество разных возможностей!
Без сомнения, для быстрой и простой реализации победителем является 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 возвращает истину для любой функции, не имеющей формальных параметров.
str.length === 0 || str === "" оба будут выполнять одну и ту же задачу.
Нет метода 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 сама по себе не решит эту проблему.
Вы можете легко добавить его к собственному объекту Нить в 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.info((typeof j == 'undefined') ? "true":"false");
var j = null;
console.info((j == null) ? "true":"false");
var j = "";
console.info((!j) ? "true":"false");
var j = "Hi";
console.info((!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.info(isEmpty()); // true
console.info(isEmpty(null)); // true
console.info(isEmpty('')); // true
console.info(isEmpty(' ')); // true
console.info(isEmpty(undefined)); // true
console.info(isEmpty({})); // true
console.info(isEmpty([])); // true
console.info(isEmpty(0)); // false
console.info(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()
Главный недостаток: это регулярное выражение соответствует строковому литералу «null». (/(null|undefined|^$)/).test("null")
Я не нашел здесь хорошего ответа (по крайней мере, ответа, который мне не подходит)
Поэтому я решил ответить себе:
value === undefined || value === null || value === "";
Вам нужно начать проверять, не определено ли оно. В противном случае ваш метод может взорваться, и тогда вы можете проверить, равен ли он нулю или пустой строке.
Вы не можете !! или только if (value), поскольку если вы проверите 0, он даст вам ложный ответ (0 - ложь).
С учетом сказанного, оберните его таким методом, как:
public static isEmpty(value: any): boolean {
return value === undefined || value === null || value === "";
}
PS .: Вам не нужно проверять тип, так как он взорвется и бросится еще до того, как войдет в метод
Вероятно, лучше использовать конструкцию Boolean (value), которая обрабатывает неопределенные и нулевые значения (а также 0, -0, false, NaN) как ложные. См. stackoverflow.com/questions/856324/…
Проверьте все следующие сценарии:
нулевой
неопределенный
0
"" (пустая строка)
ложный
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- массив, объект и функция01NaNInfinity- числаtruefalse- логическийnullundefined
Не все протестированные методы поддерживают все варианты ввода.
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.info( ' "" "a" " " [] {} 0 1 NaN Infinity f true false null undefined ');
let log1 = (s,f)=> console.info(`${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.info(`${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.info(`${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 - вы можете запускать тесты на своем компьютере здесь
Это действительно здорово! Мне нравится видеть все это выложенным! Спасибо!
Вид вводит в заблуждение, поскольку он сочетает в себе решения по отделке с решениями без отделки.
Начиная с:
return (!value || value == undefined || value == "" || value.length == 0);
Глядя на последнее условие, если value == "", его длина должен равна 0. Поэтому отбросьте его:
return (!value || value == undefined || value == "");
Но ждать! В JavaScript пустая строка неверна. Следовательно, drop value == "":
return (!value || value == undefined);
И! Undefined истинно, поэтому эта проверка не требуется. Итак, у нас есть:
return (!value);
И скобки нам не нужны:
return !value
что будет если value = false или value = 0. вернешь ли ты правильный ответ по вопросу?
if ((str?.trim()?.length || 0) > 0) {
// str must not be any of:
// undefined
// null
// ""
// " " or just whitespace
}
Обновлять: Поскольку этот ответ становится популярным, я подумал, что тоже напишу функциональную форму:
const isNotNilOrWhitespace = input => (input?.trim()?.length || 0) > 0;
const isNilOrWhitespace = input => (input?.trim()?.length || 0) === 0;
Здесь много полезной информации, но, на мой взгляд, не был затронут один из самых важных элементов.
null, undefined и "" - все фальшивка.
При оценке пустой строки это часто связано с тем, что вам нужно заменить ее чем-то другим.
В этом случае вы можете ожидать следующего поведения.
var a = ""
var b = null
var c = undefined
console.info(a || "falsy string provided") // prints ->"falsy string provided"
console.info(b || "falsy string provided") // prints ->"falsy string provided"
console.info(c || "falsy string provided") // prints ->"falsy string provided"
Имея это в виду, метод или функция, которая может возвращать независимо от того, является ли строка "", null или undefined (недопустимая строка) по сравнению с допустимой строкой, очень проста:
const validStr = (str) => str ? true : false
validStr(undefined) // returns false
validStr(null) // returns false
validStr("") // returns false
validStr("My String") // returns true
Надеюсь, это поможет.
Обрезка пробелов с помощью оператора объединения с нулем:
if (!str?.trim()) {
// do something...
}
Выглядит круто, но достаточно str.trim (). ИМО никогда не следует усложнять вещи.
Просто выбрасываю для тех, кому это может понадобиться. ?. не может быть менее сложным. .trim() выдаст ошибку, если значение str равно нулю.
Эта функция хорошо сработала для меня, гарантируя, что это одновременно строка, а не пустая:
isNonBlankString = function(s) { return ((typeof s === 'string' || s instanceof String) && s !== ''); }
в случае проверки пустой строки просто
if (str.length){
//do something
}
если вы также хотите включить в свой чек null и undefined, просто
if (Boolean(str)){
//this will be true when the str is not empty nor null nor undefined
}
Вы можете проверить это, используя оператор typeof вместе с методом length.
const isEmptyString = (value) => typeof(value) == 'string' && value.length > 0
просто FYI, я думаю, что наиболее полезные API для класса String находятся в Mozilla и набор javascript. [elated.com] (elated.com/articles/working-with-strings) содержит руководство по всем свойствам, методам String ... Обратите внимание: ссылка Mozilla была обновлена до developer.mozilla.org/en/JavaScript/Reference/Global_Objects /…