Як я можу перевірити наявність порожнього / невизначеного / нульового рядка в JavaScript?

Я бачив це запитання , але конкретного прикладу JavaScript не бачив. Чи string.Emptyє в JavaScript доступний простий доступ, чи це лише випадок перевірки ""?

Якщо ви просто хочете перевірити, чи є якесь значення, можете зробити

if (strValue) {
    //do something
}

Якщо вам потрібно перевірити спеціально для порожнього рядка над нулем, я думаю , що перевірка проти ""є кращим вибором, використовуючи в ===оператора (так що ви знаєте , що це, насправді, рядок ви порівнюєте проти).

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

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

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)){
    // Code here
}

Обидва виконують однакову функцію. Введіть змінну в булева, де strє змінна.
Він повертається falseза null,undefined,0,000,"",false.
Він повертається trueдля рядка "0" та пробілів "".

Найближче до чого можна дістатися str.Empty(за умови, що str - це String):

if (!str.length) { ...

Якщо вам потрібно переконатися, що рядок - це не лише купа порожніх пробілів (я припускаю, що це для перевірки форми), вам потрібно зробити заміну на пробіли.

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

Я використовую:

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

Ви можете використовувати lodash : _.isEmpty (значення).

Вона охоплює багато випадків , як {}, '', null, undefinedі т.д.

Але він завжди повертається trueдля Numberтипу примітивних типів JavaScript, таких як _.isEmpty(10)або _.isEmpty(Number.MAX_VALUE)обидва true.

Функція:

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;

Спробуйте:

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

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

В JavaScript нічого не представляє порожній рядок. Зробіть перевірку на або length(якщо ви знаєте, що var завжди буде рядком), або проти""

Я б не переймався надто ефективним методом. Використовуйте те, що найбільш зрозуміло вашому наміру. Для мене це зазвичайstrVar == "" .

Відповідно до коментаря Константина , якби strVar міг би дещо отримати ціле число 0, то це справді буде однією з таких ситуацій, що з'ясовують намір.

Дуже багато відповідей, і багато різних можливостей!

Без сумніву, для швидкої та простої реалізації переможець: 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;
    }
}

Трохи надмірне, я знаю.

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

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

Перевіряє рядки, порожні або заповнені пробілом.

1. перевірити, чи var a;існують

2. обріжте значення false spacesу значенні, а потім протестуйте наemptiness

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

Продуктивність

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

Висновки

• прості рішення , засновані на !str, ==, ===іlength швидко для всіх браузерів (А, В, С, 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 - ви можете запустити тести на своїй машині тут

Крім того, якщо ви вважаєте рядок, заповненим пробілом, "порожнім".

Ви можете перевірити його за допомогою цього регулярного виразу:

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

Я зазвичай використовую щось подібне,

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

Я не помітив відповіді, яка враховує можливість нульових символів у рядку. Наприклад, якщо у нас є нульовий рядок символів:

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

Тим часом у нас може бути одна функція, яка перевіряє всі "порожні", такі як 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.

}

Використовуючи це, ви також можете переконатися, що рядок також не визначений або недійсний. Пам'ятайте, що невизначені, нульові та порожні - це три різні речі.

Усі ці відповіді приємні.

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

Я не побачив тут гарної відповіді (принаймні, не відповіді, яка мені підходить)

Тому я вирішив відповісти собі:

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

Потрібно почати перевірку, чи вона не визначена. Інакше ваш метод може вибухнути, і тоді ви можете перевірити, чи дорівнює нулю чи дорівнює порожній рядку.

Ви не можете !! або тільки if(value)тому, що якщо ви перевіряєте, 0він дасть вам помилкову відповідь (0 - неправдиво).

З урахуванням сказаного, завершіть його таким способом:

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

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

Якщо потрібно виявити не лише порожні, але й порожні рядки, я додам до відповіді Гораля:

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

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

Спробуйте це

str.value.length == 0

Ви можете легко додати його до рідного об’єкта 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

Спробуйте це:

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

Я провів кілька досліджень щодо того, що відбувається, якщо ви передасте не рядкове і не порожнє / нульове значення функції тестера. Як багато хто знає, (0 == "") вірно в JavaScript, але оскільки 0 є значенням, а не порожнім або нульовим, ви можете перевірити його.

Наступні дві функції повертають істинні лише для невизначених, нульових, порожніх / значень пробілів та помилок для всього іншого, таких як числа, булеві, об'єкти, вирази тощо.

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

Існують більш складні приклади, але вони прості і дають стійкі результати. Немає необхідності перевіряти невизначеність, оскільки вона включена у перевірку (value == null). Ви також можете імітувати поведінку C # , додавши їх до String так:

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

Щоб перевірити, чи це точно порожній рядок:

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

Щоб перевірити, чи це порожній рядок АБО логічний еквівалент не-значення (null, undefined, 0, NaN, false, ...):

if(!val)...

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

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

Перевірка типу необхідна для того , щоб уникнути помилок під час виконання , коли testце undefinedабо null.

Ігноруючи рядки пробілів, ви можете використовувати це для перевірки наявності нуля, порожнього та невизначеного:

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

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

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

Це стисло і працює для невизначених властивостей, хоча це не найчитабельніше.