Как проверить пустую строку в JavaScript?
Я видел этот нить, но я не видел конкретного примера JavaScript. Есть простой string.Empty
доступные в JavaScript, или это просто случай проверки ""
?
30 ответов
если вы просто хотите проверить, есть ли какое-либо значение, вы можете сделать
if (strValue) {
//do something
}
Если вам нужно проверить специально для пустой строки над null, я бы подумал, что проверка против ""
ваш лучший выбор, используя на ===
оператор (чтобы вы знали, что на самом деле это строка, с которой вы сравниваете).
if (strValue === "") {
//...
}
для проверки, если строка пуста, null или undefined я использую:
function isEmpty(str) {
return (!str || 0 === str.length);
}
для проверки, является ли строка пустой, нулевой или неопределенной я использую:
function isBlank(str) {
return (!str || /^\s*$/.test(str));
}
для проверки, является ли строка пустой или содержит только пробел:
String.prototype.isEmpty = function() {
return (this.length === 0 || !this.trim());
};
все вышесказанное хорошо, но это будет еще лучше. использовать !!
(не оператор).
if(!!str){
some code here;
}
или использовать тип отливки:
if(Boolean(str)){
codes here;
}
оба выполняют одну и ту же функцию, введите cast переменную в boolean, где str
- это переменная.
Возвращает false
на null,undefined,0,000,"",false
.
Возвращает true
для строки " 0 "и пробелов"".
Если вам нужно убедиться, что строка не просто куча пустых пространств (я предполагаю, что это для проверки формы), вам нужно сделать замену на пробелы.
if(str.replace(/\s/g,"") == ""){
}
самое близкое, что вы можете получить к str.Empty
(с предварительным условием, что str является строкой):
if (!str.length) { ...
Я использую :
function empty(e) {
switch (e) {
case "":
case 0:
case "0":
case null:
case false:
case typeof this == "undefined":
return true;
default:
return false;
}
}
empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
return ""
})) // false
var s; // undefined
var s = ""; // ""
s.length // 0
в JavaScript нет ничего, представляющего пустую строку. Сделайте проверку против любого length
(Если вы знаете, что var всегда будет строкой) или против ""
Я бы не стал слишком беспокоиться о самом эффективное метод. Используйте то, что наиболее ясно вашему намерению. Для меня это обычно strVar == ""
.
EDIT: за комментарий от Константин, если strVar может каким-то образом содержать целое значение 0, то это действительно будет одна из тех ситуаций, проясняющих намерения.
функция:
function Is_Empty_or_Undefined (MyVar)
{
return
(
(typeof MyVar== 'undefined')
||
(MyVar == null)
||
(MyVar == false) //same as: !MyVariable
||
(MyVar.length == 0)
||
(MyVar == "")
||
(MyVar.replace(/\s/g,"") == "")
||
(!/[^\s]/.test(MyVar))
||
(/^\s*$/.test(MyVar))
);
}
можно использовать лодашь : _.isEmpty (значение).
он охватывает множество случаев, таких как {}
, ''
, null
, undefined
etc.
но он всегда возвращает true
на Number
типа Примитивные Типы Данных Javascript как _.isEmpty(10)
или _.isEmpty(Number.MAX_VALUE)
как возвращает true
.
вы также можете пойти с regexps:
if((/^\s*$/).test(str)) { }
проверяет наличие пустых или заполненных пробелами строк.
- проверяем, что
var a;
exist -
обрезать
false spaces
в значении, затем проверьте дляemptiness
if ((a)&&(a.trim()!='')) { // if variable a is not empty do this }
много ответов, и много разных возможностей!
без сомнения, для быстрой и простой реализации победителем является: if (!str.length) {...}
однако, как и многие другие примеры доступны. Лучший функциональный метод для этого, я бы предложил:
function empty(str)
{
if (typeof str == 'undefined' || !str || str.length === 0 || str === "" || !/[^\s]/.test(str) || /^\s*$/.test(str) || str.replace(/\s/g,"") === "")
{
return true;
}
else
{
return false;
}
}
немного чрезмерно, я знаю.
кроме того, если вы считаете строку, заполненную пробелами, "пустой". Вы можете проверить его с помощью этого регулярного выражения:
!/\S/.test(string); // Returns true if blank.
Я не заметил ответа, который учитывает возможность нулевых символов в строке. Например, если у нас есть нулевая символьная строка:
var y = ""; // an empty string, but has a null character
(y === "") // false, testing against an empty string does not work
(y.length === 0) // false
(y) // true, this is also not expected
(y.match(/^[\s]*$/)) // false, again not wanted
чтобы проверить его ничтожность, можно сделать что-то вроде этого:
String.prototype.isNull = function(){
return Boolean(this.match(/^[]*$/));
}
...
"".isNull() // true
он работает на нулевой строке и на пустой строке, и он доступен для всех строк. Кроме того, он может быть расширен, чтобы содержать другие пустые символы JavaScript или пробелы (т. е. неразрывное пространство, Знак порядка байтов, строки/абзаца сепаратор, etc.).
Если нужно обнаружить не только пустые, но и пустые строки, я добавлю к ответу Goral:
function isEmpty(s){
return !s.length;
}
function isBlank(s){
return isEmpty(s.trim());
}
Я использую комбинацию, сначала самые быстрые проверки.
function isBlank(pString){
if (!pString || pString.length == 0) {
return true;
}
// checks for a non-white space character
// which I think [citation needed] is faster
// than removing all the whitespace and checking
// against an empty string
return !/[^\s]+/.test(pString);
}
игнорируя строки пробелов, вы можете использовать это для проверки null, empty и undefined:
var obj = {};
(!!obj.str) //returns false
obj.str = "";
(!!obj.str) //returns false
obj.str = null;
(!!obj.str) //returns false
краткий и он работает для неопределенных свойств, хотя он не самый читаемый.
все эти ответы хороши.
но я не могу быть уверен, что переменная является строкой, не содержит только пробелы (это важно для меня) и может содержать " 0 " (строка).
мой вариант:
function empty(str){
return !str || !/[^\s]+/.test(str);
}
empty(null); // true
empty(0); // true
empty(7); // false
empty(""); // true
empty("0"); // false
empty(" "); // true
образец jsfiddle.
Я провел некоторое исследование, что произойдет, если вы передадите нестроковое и непустое/нулевое значение функции тестера. Как многие знают, (0 == "") истинно в javascript, но поскольку 0 является значением, а не пустым или нулевым, вы можете проверить его.
следующие две функции возвращают true только для значений undefined, null, empty / whitespace и false для всего остального, такого как числа, boolean, объекты, выражения и т. д.
function IsNullOrEmpty(value)
{
return (value == null || value === "");
}
function IsNullOrWhiteSpace(value)
{
return (value == null || !/\S/.test(value));
}
более сложные примеры есть, но эти просты и дают последовательные результаты. Нет необходимости тестировать undefined, так как он включен в проверку (value == null). Вы также можете имитировать поведение C#, добавляя их в строку следующим образом:
String.IsNullOrEmpty = function (value) { ... }
вы не хотите помещать его в прототип строк, потому что, если экземпляр String-class равен null, это приведет к ошибке:
String.prototype.IsNullOrEmpty = function (value) { ... }
var myvar = null;
if (1 == 2) { myvar = "OK"; } // could be set
myvar.IsNullOrEmpty(); // throws error
Я тестировал со следующим массивом значений. Вы можете зациклить его, чтобы проверить свои функции, если сомневаетесь.
// Helper items
var MyClass = function (b) { this.a = "Hello World!"; this.b = b; };
MyClass.prototype.hello = function () { if (this.b == null) { alert(this.a); } else { alert(this.b); } };
var z;
var arr = [
// 0: Explanation for printing, 1: actual value
['undefined', undefined],
['(var) z', z],
['null', null],
['empty', ''],
['space', ' '],
['tab', '\t'],
['newline', '\n'],
['carriage return', '\r'],
['"\r\n"', '\r\n'],
['"\n\r"', '\n\r'],
['" \t \n "', ' \t \n '],
['" txt \t test \n"', ' txt \t test \n'],
['"txt"', "txt"],
['"undefined"', 'undefined'],
['"null"', 'null'],
['"0"', '0'],
['"1"', '1'],
['"1.5"', '1.5'],
['"1,5"', '1,5'], // valid number in some locales, not in js
['comma', ','],
['dot', '.'],
['".5"', '.5'],
['0', 0],
['0.0', 0.0],
['1', 1],
['1.5', 1.5],
['NaN', NaN],
['/\S/', /\S/],
['true', true],
['false', false],
['function, returns true', function () { return true; } ],
['function, returns false', function () { return false; } ],
['function, returns null', function () { return null; } ],
['function, returns string', function () { return "test"; } ],
['function, returns undefined', function () { } ],
['MyClass', MyClass],
['new MyClass', new MyClass()],
['empty object', {}],
['non-empty object', { a: "a", match: "bogus", test: "bogus"}],
['object with toString: string', { a: "a", match: "bogus", test: "bogus", toString: function () { return "test"; } }],
['object with toString: null', { a: "a", match: "bogus", test: "bogus", toString: function () { return null; } }]
];
чтобы проверить, является ли точно пустой строкой:
if(val==="")...
чтобы проверить, является ли это пустой строкой или логическим эквивалентом для no-value (null, undefined, 0, NaN, false, ...):
if(!val)...
нет isEmpty()
метод, вы должны проверить тип и длина:
if (typeof test === 'string' && test.length === 0){
...
проверка типа необходима, чтобы избежать ошибок во время выполнения, когда test
и undefined
или null
.
между тем мы можем иметь одну функцию, которая проверяет все "пустые", как null, undefined, ", ' ', {}, []. Поэтому я просто написал это.
var isEmpty = function(data) {
if(typeof(data) === 'object'){
if(JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]'){
return true;
}else if(!data){
return true;
}
return false;
}else if(typeof(data) === 'string'){
if(!data.trim()){
return true;
}
return false;
}else if(typeof(data) === 'undefined'){
return true;
}else{
return false;
}
}
варианты использования и результаты.
console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty(' ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false
function tell()
{
var pass = document.getElementById('pasword').value;
var plen = pass.length;
now you can check if your string is empty as like
if(plen==0)
{
alert('empty');
}
else
{
alert('you entered something');
}
}
<input type='text' id='pasword' />
это также общий способ проверить, является ли поле пустым.
Не предполагайте, что переменная, которую вы проверяете, является строкой. Не предполагайте, что если этот var имеет длину, то это строка.
дело в том, что: тщательно подумайте о том, что ваше приложение должно делать и может принять. Постройте что-нибудь надежное.
Если ваш метод / функция должны обрабатывать только непустую строку, то проверьте, является ли аргумент непустой строкой и не делайте какой-то "трюк".
в качестве примера чего-то, что взорвется, если вы будете следовать некоторым советам здесь не внимательно.
var getLastChar = function (str) {
if (str.length > 0)
return str.charAt(str.length - 1)
}
getLastChar('hello')
=> "o"
getLastChar([0,1,2,3])
=> TypeError: Object [object Array] has no method 'charAt'
Итак, я остался с
if (myVar === '')
...
вы также должны всегда проверять тип, так как JavaScript-это типизированный язык duck, поэтому вы можете не знать, когда и как данные изменились в середине процесса. Итак, вот лучшее решение:
var str = "";
if (str === "") {
//...
}