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

3338
casademora 30 Сен 2008 в 21:17

30 ответов

Лучший ответ

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

if (strValue) {
    //do something
}

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

if (strValue === "") {
    //...
}
3479
guest 2 Июн 2018 в 00:29

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

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

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

41
Peter Mortensen 9 Мар 2020 в 00:17

Для проверки, является ли строка пустой, нулевой или неопределенной, я использую:

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());
};
1102
Scott Harwell 13 Май 2014 в 14:00

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

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

27
Peter Mortensen 8 Мар 2020 в 23:39

На данный момент нет прямого метода, такого как 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.

}

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

10
Harshit Agarwal 3 Сен 2019 в 08:25

Функция:

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;

36
Peter Mortensen 9 Мар 2020 в 00:01

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

if(!!str){
    // Some code here
}

Или используйте тип литья:

if(Boolean(str)){
    // Code here
}

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

303
Peter Mortensen 8 Мар 2020 в 23:45

Ближайшая вещь, которую вы можете получить к str.Empty (при условии, что str является String):

if (!str.length) { ...
103
Kick Buttowski 31 Авг 2018 в 16:08

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

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

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

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

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

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

7
Peter Mortensen 8 Мар 2020 в 23:47

Пытаться:

if (str && str.trim().length) {  
    //...
}
35
afuzzyllama 9 Янв 2013 в 03:15

Я использую:

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
65
Peter Mortensen 8 Мар 2020 в 23:39

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

if(str.replace(/\s/g,"") == ""){
}
98
Sugendran 30 Сен 2008 в 23:08

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

if (!str.length) {
    // Do something
}
14
Peter Mortensen 8 Мар 2020 в 23:58

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

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

10
Peter Mortensen 8 Мар 2020 в 23:52

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

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

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

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

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

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

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

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

9
Peter Mortensen 9 Мар 2020 в 00:21

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

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

< STRONG> Выводы

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

Enter image description here

Детали

В следующем фрагменте я сравниваю результаты выбранных 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 - вы можете запускать тесты на своем компьютере здесь

Enter image description here

10
Kamil Kiełczewski 9 Мар 2020 в 06:03

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

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

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

20
Peter Mortensen 8 Мар 2020 в 23:39

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

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

function isBlank(s){
    return isEmpty(s.trim());    
}
9
Josef.B 1 Окт 2014 в 06:55
var s; // undefined
var s = ""; // ""
s.length // 0

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

34
cllpse 30 Сен 2008 в 17:42

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

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

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

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

if(!val)...
8
Peter Mortensen 9 Мар 2020 в 00:16

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

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);
}
7
Peter Mortensen 8 Мар 2020 в 23:49

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

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

Я немного излишне знаю.

19
tfont 14 Сен 2018 в 08:25

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

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

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

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

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

Вы не хотите помещать его в прототип Strings, потому что если экземпляр класса String равен нулю, он выдаст ошибку:

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; } }]
];
7
Peter Mortensen 8 Мар 2020 в 23:55

Попробуй это

str.value.length == 0
8
Neuron 8 Янв 2019 в 04:39

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

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

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

7
Agustí Sánchez 4 Ноя 2016 в 22:28

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

export const isEmpty = string => (!string || !string.length);
8
CroMagnon 14 Июн 2019 в 11:01

Кроме того, в случае, если вы рассматриваете заполненную пробелом строку как «пустую».

Вы можете проверить это с помощью этого регулярного выражения:

!/\S/.test(string); // Returns true if blank.
16
Peter Mortensen 8 Мар 2020 в 23:55

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

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

10
Bikush 31 Июл 2012 в 14:05