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

avatar
casademora
30 сентября 2008 в 17:17
3899413
60
3316

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

Источник
Gene T
2 октября 2008 в 15:16
4

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

Himanshu Shekhar
13 мая 2019 в 10:58
0

Отметьте это: coderhelper.com/a/36491147/7026966

RobG
16 октября 2019 в 12:47
1

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

Omar bakhsh Available to work
31 января 2021 в 04:29
0

str.length> -1

Flimm
11 августа 2021 в 14:59
0

Полностью согласен с @RobG, этот вопрос плохо сформулирован. Почему вы считаете null или undefined пустыми? Пустая строка - это пустая строка, это не null или undefined

Flimm
11 августа 2021 в 15:20
0

Кроме того, пустая строка не может содержать пробелов, как предполагается во многих ответах!

Ответы (60)

avatar
bdukes
30 сентября 2008 в 17:20
4152

Если вы просто хотите проверить, существует ли истинное значение, вы можете сделать:

if (strValue) {
    //do something
}

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

if (strValue === "") {
    //...
}
Vincent Robert
1 октября 2008 в 20:07
222

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

bdukes
27 сентября 2010 в 13:19
52

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

Vincent Robert
27 сентября 2010 в 16:18
35

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

CodeClimber
3 октября 2011 в 15:02
29

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

Chad
28 ноября 2011 в 21:54
130

Как и ожидалось, .length > 0 на самом деле намного быстрее , чем по сравнению со строковым литералом! Посмотрите этот jsPerf

David Mulder
27 февраля 2014 в 20:45
4

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

CTS_AE
16 апреля 2018 в 23:56
0

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

rashidnk
4 мая 2018 в 09:24
2

str = 0; если (строка) вернуть ложь

kir.gera
23 мая 2018 в 08:05
0

что, если нам нужно пройти эту проверку как lamda? f.e: if (users.some (u => u.GroupRole)) {} В этом случае есть ошибка компиляции, говорящая мне передать bool, а не строку

bdukes
23 мая 2018 в 14:04
1

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

HamidReza Heydari
12 июня 2019 в 08:18
0

@casademora Это плохой ответ, потому что в некоторых ситуациях при запуске создается страница, инициализируемая null, и этот strValue === "" не работает. лучший синтаксис: !strValue GoodLuck

sarkiroka
2 апреля 2020 в 15:39
3

Прежде чем сосредоточиться на разнице в производительности, подумайте, сколько раз он будет запускаться. Например, если оператор «if» запускается один раз для каждого сайта, оптимизация производительности близка к нулю. и если ваш код длиннее оригинала, возможно, вы потеряете больше времени в сети, чем выиграете при выполнении javascript. И, наконец, когда вы используете какой-либо инструмент для сборки, эта микрооптимализация будет потеряна. Так что мой совет: «пишите более читаемый код».

Mike Brockington
22 июля 2021 в 09:10
0

Удивлен, что не увидел здесь ни одного упоминания о «ложных ценностях» ...

avatar
sMyles
9 ноября 2021 в 21:04
-2

Вот некоторые пользовательские функции, которые я использую для обработки этого. Наряду с примерами работы кода.

const v1 = 0
const v2 = '4'
const v2e = undefined
const v2e2 = null
const v3 = [1, 2, 3, 4]
const v3e = []
const v4 = true
const v4e = false
const v5 = {
  test: 'value'
}
const v5e = {}
const v6 = 'NotEmpty'
const v6e = ''

function isNumeric(n) {
  return !isNaN(parseFloat(n)) && isFinite(n)
}

function isEmpty(v, zeroIsEmpty = false) {
  /**
   * When doing a typeof check, null will always return "object" so we filter that out first
   * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof#typeof_null
   */
  if (v === null) {
    return true
  }

  if (v === true) {
    return false
  }

  if (typeof v === 'object') {
    return !Object.keys(v).length
  }

  if (isNumeric(v)) {
    return zeroIsEmpty ? parseFloat(v) === 0 : false
  }

  return !v || !v.length || v.length < 1
}

console.log(isEmpty(v1), isEmpty(v1, true))
console.log(isEmpty(v2), isEmpty(v2e), isEmpty(v2e))
console.log(isEmpty(v3), isEmpty(v3e))
console.log(isEmpty(v4), isEmpty(v4e))
console.log(isEmpty(v5), isEmpty(v5e))
console.log(isEmpty(v6), isEmpty(v6e))

Также для справки, вот источник lodash isEmpty: https://github.com/lodash/lodash/blob/master/isEmpty.js

avatar
Ali Yaghoubi
13 октября 2021 в 18:13
3

Это значение falsy. Ложные значения

Первое решение:

const str = "";
return str || "Hello"

Второе решение:

const str = "";
return (!!str) || "Hello"; // !!str is Boolean

Третье решение:

const str = "";
return (+str) || "Hello"; // !!str is Boolean
devildelta
17 ноября 2021 в 08:21
1

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

avatar
Anis KCHAOU
8 октября 2021 в 07:56
3

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

function isEmpty(strValue)
{
      // Test whether strValue is empty
    if (!strValue || strValue.trim() === "" || (strValue.trim()).length === 0) {
        //do something
    }
}
pys
27 декабря 2021 в 12:09
1

Какова цель (strValue.trim()).length === 0) в конце условия? Разве это не избыточно с strValue.trim() === ""?

avatar
Vicky P
13 сентября 2021 в 12:31
4

Просто проверьте, существует ли переменная и не является ли она пустой.

//let Str = "";
if (Str && Str.length !== 0) {
  console.log("String is not empty");
}
avatar
CrazyStack
22 августа 2021 в 10:12
1

Последний и самый короткий вариант функции isBlank:

/**
 * Will return:
 * False for: for all strings with chars
 * True for: false, null, undefined, 0, 0.0, "", " ".
 *
 * @param str
 * @returns {boolean}
 */
function isBlank(str){
    return (!!!str || /^\s*$/.test(str));
}

// tests
console.log("isBlank TRUE variants:");
console.log(isBlank(false));
console.log(isBlank(undefined));
console.log(isBlank(null));
console.log(isBlank(0));
console.log(isBlank(0.0));
console.log(isBlank(""));
console.log(isBlank(" "));

console.log("isBlank FALSE variants:");
console.log(isBlank("0"));
console.log(isBlank("0.0"));
console.log(isBlank(" 0"));
console.log(isBlank("0 "));
console.log(isBlank("Test string"));
console.log(isBlank("true"));
console.log(isBlank("false"));
console.log(isBlank("null"));
console.log(isBlank("undefined"));
avatar
Labham Jain
4 июля 2021 в 06:16
0

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

const checkEmpty = string => (string.trim() === "") || !string.trim();

Использование:

checkEmpty(""); // returns true.
checkEmpty("mystr"); // returns false.

Это чертовски просто. :)

Flimm
11 августа 2021 в 15:28
0

Это вернет true даже для непустых строк, содержащих пробелы, например " ".

avatar
RationalRabbit
23 июня 2021 в 15:29
-2

Я попробовал несколько примеров, предложенных здесь. Моя цель состояла в том, чтобы иметь возможность проверять не только пусто, но и !empty. Это был результат Единственное, что я не мог найти ни в одном из этих решений, это как обнаружить undefined внутри функции, если она, по крайней мере, не была объявлена. возможно, это невозможно.

Я расширил это, включив в него массивы. Проверьте скрипку. это работает.

function empty(data)
{
    if(Array.isArray(data) && !data.length)
    {
       return true;
    }
    if(typeof data === "undefined")
    {
        return true;
    }
    else if(data === "0")
    {
        return true;
    }
    else if(!data)
    {
        return true;
    }
    else if(/\S/.test(data) == "")
    {
        return true;
    }
    else
    {
        return false;
    }
}

Тестирование

var One = "    "; if(empty(One)) // true
var One = ""; if(empty(One)) // true
var One = 0; if(empty(One)) // true
var One = "0"; if(empty(One)) //true
var One = NaN; if(empty(One)) // true
var One = null; if(empty(One)) // true
var One = false; if(empty(One)) //true
var Two; if(empty(Two) //True
var One = []; // true
var One = ["One", "Two", "Three"] //false
============
Not Empty
============
var One = "     "; if(!empty(One)) //false (empty)
var One = ""; if(!empty(One)) //false
var One = 6; if(!empty(One)) //true
var One = "seven"; if(!empty(One)) //true
var One = NaN; if(!empty(One)) // false
var One = null; if(!empty(One)) //false
var One = false; if(!empty(One)) //false
Var Two; if(!empty(Two)) // false (undefined)
var One = []; // false
var One = ["One", "Two", "Three"] //true
RationalRabbit
12 августа 2021 в 01:55
0

Обновленная скрипта jsfiddle.net/RationalRabbit/axyhe5m1/62

avatar
nntona
16 июня 2021 в 11:33
-1

Это еще один тип с опцией обрезки строк, защищенный от ошибок:

let strTest = " ";

console.log("Is empty string?",isEmptyString(strTest)); // without trim

console.log("Is empty string?",isEmptyString(strTest,true)); // with trim (escape left and right white spaces)

strTest = "abcd ";

console.log("Is empty string?",isEmptyString(strTest)); // without trim
console.log("Is empty string?",isEmptyString(strTest,true)); // with trim

function isEmptyString(str, withTrim = false) { 
  try {
    if (withTrim){
      if (str.trim()) return false;
      else return true;
    }
    else{
      if (str) return false;
      else return true;
    }
  } catch (error) {
    return true;
  }
}
avatar
Siwei
12 июня 2021 в 08:58
0

для тех, кто ищет рельсы .blank? для строки js:

function is_blank(str) { 
  return (!str || str.length === 0 || str.trim() == '')
}
avatar
Anastasios Tsournos
14 января 2021 в 17:04
3

Вы можете проверить это, используя оператор typeof вместе с методом длины.

const isNonEmptyString = (value) => typeof(value) == 'string' && value.length > 0

отредактировано в соответствии с предложением @kip2.

kip2
13 мая 2021 в 09:12
0

разве имя не должно быть больше похоже на isNonEmptyString() или isValidString()? в настоящее время он выглядит перевернутым...

avatar
Ibrahim shamma
2 января 2021 в 11:24
10

в случае проверки пустой строки просто

if (str.length){
  //do something
}

, если вы также хотите включить null и undefined в свою проверку, просто

if (Boolean(str)){
  //this will be true when the str is not empty nor null nor undefined
}
avatar
Mike Hanson
15 декабря 2020 в 16:58
0

Эта функция хорошо сработала для меня, гарантируя, что это и строка, и не пустая:

isNonBlankString = function(s) { return ((typeof s === 'string' || s instanceof String) && s !== ''); }

Flimm
11 августа 2021 в 15:29
0

Разве не достаточно просто сделать s === ""?

avatar
sean
4 декабря 2020 в 09:55
10

Обрезка пробелов с помощью оператора объединения с нулем:

if (!str?.trim()) {
  // do something...
}
Hexodus
23 февраля 2021 в 15:16
0

Выглядит круто, но достаточно str.trim (). ИМО никогда не следует усложнять вещи.

sean
24 февраля 2021 в 10:48
1

Просто выбрасываю для тех, кому это может понадобиться. ?. не может быть менее сложным. .trim() выдаст ошибку, если str имеет значение NULL.

avatar
trn450
5 ноября 2020 в 19:24
6

Здесь много полезной информации, но, на мой взгляд, один из самых важных элементов не был затронут.

null, undefined и "" являются ложными.

При оценке пустой строки часто это происходит потому, что вам нужно заменить ее чем-то другим.

В этом случае можно ожидать следующего поведения.

var a = ""
var b = null
var c = undefined

console.log(a || "falsy string provided") // prints ->"falsy string provided"
console.log(b || "falsy string provided") // prints ->"falsy string provided"
console.log(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

Надеюсь, это было полезно.

avatar
Ibraheem
24 августа 2020 в 09:55
9
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;
gfan
7 декабря 2021 в 12:59
0

не могли бы вы дать больше пояснений?

avatar
Abhishek Luthra
10 февраля 2020 в 08:34
12

Начиная с:

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
nerez
28 апреля 2020 в 04:15
0

что произойдет, если value = false или value = 0. вернешь ли ты правильный ответ по вопросу?

avatar
Kamil Kiełczewski
31 декабря 2019 в 18:48
46

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

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

Выводы

  • простые решения на основе !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

WebWanderer
24 января 2020 в 19:15
1

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

sean
4 декабря 2020 в 09:47
1

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

avatar
Davi Daniel Siepmann
23 октября 2019 в 21:13
11

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

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

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

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

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

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

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

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

Zhuravlev A.
29 ноября 2019 в 14:34
0

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

avatar
Japesh
18 октября 2019 в 09:02
5

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

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

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

(/(null|undefined|^$|^\d+$)/).test()
sean
4 декабря 2020 в 09:50
2

Главный недостаток: это регулярное выражение соответствует строковому литералу "null". (/(null|undefined|^$)/).test("null")

avatar
oviniciusfeitosa
10 мая 2019 в 21:33
9

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

export const isEmpty = string => (!string || !string.length);
avatar
Harshit Agarwal
11 апреля 2019 в 12:16
11

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

whoami - fakeFaceTrueSoul
17 апреля 2019 в 15:45
0

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

RobG
16 октября 2019 в 12:51
0

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

Harshit Agarwal
15 ноября 2019 в 05:07
0

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

avatar
Imran Ahmad
12 марта 2018 в 08:48
11

Между тем у нас может быть одна функция, которая проверяет все «пустые», такие как 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
avatar
KARTHIKEYAN.A
30 ноября 2017 в 06:26
6

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

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");
avatar
Alireza
7 октября 2017 в 02:33
7

Вы можете легко добавить его к собственному объекту 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
John Montgomery
3 февраля 2020 в 22:46
0

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

sean
4 декабря 2020 в 09:51
1

Пожалуйста, не загрязняйте прототипы.

Flimm
11 августа 2021 в 15:22
0

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

avatar
Moshii
17 августа 2017 в 06:51
54

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

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

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

Erich
13 февраля 2020 в 15:56
0

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

Moshii
25 марта 2020 в 07:34
2

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

Erich
26 марта 2020 в 00:30
1

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

avatar
Luca C.
2 июня 2017 в 08:33
10

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

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

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

if(!val)...
avatar
Agustí Sánchez
4 ноября 2016 в 22:28
9

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

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

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

Flimm
11 августа 2021 в 15:21
0

Я почти уверен, что test === "" эквивалентен, и он короче.

avatar
tfont
31 марта 2016 в 08:29
21

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

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

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

SvdSinner
16 июня 2016 в 14:10
2

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

tfont
17 июня 2016 в 15:17
0

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

RobG
16 октября 2019 в 12:52
0

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

Praveen M P
3 ноября 2020 в 12:06
0

str.length === 0 || str === "" оба будут выполнять одну и ту же задачу.

avatar
Thaddeus Albers
10 июня 2015 в 08:44
4

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

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

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

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

_.isEmpty({});
=> правда

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

avatar
KanimozhiPalanisamy
25 марта 2015 в 09:37
-6
<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>
Peter Mortensen
9 марта 2020 в 00:04
0

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

avatar
Timothy Nwanwene
24 февраля 2015 в 15:38
20
  1. проверьте, что var a; существует
  2. обрезать false spaces в значении, затем проверить на emptiness

    if ((a)&&(a.trim()!=''))
    {
      // if variable a is not empty do this 
    }
    
Flimm
11 августа 2021 в 15:18
0

Строка " " не пуста, но по этому условию она будет считаться пустой.

avatar
Josef.B
1 октября 2014 в 06:55
13

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

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

function isBlank(s){
    return isEmpty(s.trim());    
}
avatar
Alban Kaperi
19 июля 2014 в 18:15
-10

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

var str = "Hello World!";
if(str === ''){alert("THE string str is EMPTY");}

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

var str = "Hello World!";
if(typeof(str) === 'string'){alert("This is a String");}
Green
30 декабря 2015 в 13:50
3

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

Scott Marcus
28 января 2016 в 21:55
0

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

avatar
Sazid
6 мая 2014 в 06:38
5

Вы также всегда должны проверять тип, так как 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");
    }
Flimm
11 августа 2021 в 15:25
0

Первое условие работает для любого ложного значения, а не только undefined. Этот ответ не проверяет тип.

avatar
Gaurav
8 апреля 2014 в 09:37
-1
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")
}
avatar
T.Todua
27 февраля 2014 в 20:31
42

Универсальная функция универсального типа ( не рекомендуется, но ):

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

Однако я не рекомендую использовать это, потому что ваша целевая переменная должна быть определенного типа (например, строковая, числовая или объектная?), Поэтому примените проверки, относящиеся к этой переменной.

DanV
21 марта 2014 в 12:13
2

Есть ли шанс, что вы могли бы объяснить, что делает каждая проверка? :)

Bennett McElwee
1 апреля 2014 в 22:39
3

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

Scott Marcus
28 января 2016 в 21:57
2

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

avatar
user2086641
9 августа 2013 в 10:10
17

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

if (!str.length) {
    // Do something
}
Adrian Hope-Bailie
20 февраля 2014 в 10:16
4

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

Abimael Martell
1 апреля 2014 в 00:18
0

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

Adrian Hope-Bailie
1 апреля 2014 в 08:28
3

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

Abimael Martell
1 апреля 2014 в 18:56
0

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

avatar
Kev
15 июля 2013 в 10:55
7

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

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

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

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


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 === '')
  ...
Flimm
11 августа 2021 в 15:23
0

Этот ответ должен быть закреплен наверху.

avatar
Mubashar
3 июля 2013 в 04:16
4

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

function isNotBlank(str) {
   return (str && /^\s*$/.test(str));
}
Mike Viens
1 мая 2019 в 22:21
3

Вводить отрицание в имена функций — плохая идея. Ваш код сам по себе в порядке, но функция должна называться как-то вроде hasValue(). Почему? Что происходит, когда вы видите такой код: "if (!isNotBlank(str))"... Не сразу понятно, каково должно быть намерение. Этот простой пример может показаться вам неуместным, но добавление отрицания к имени функции — всегда плохая идея.

Mubashar
2 мая 2019 в 00:34
0

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

Mubashar
2 мая 2019 в 00:44
0

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

avatar
Wab_Z
15 мая 2013 в 14:55
17

Также, если вы считаете строку, заполненную пробелами, "пустой".

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

!/\S/.test(string); // Returns true if blank.
avatar
JHM
14 мая 2013 в 10:18
10

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

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

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; } }]
];
Scott Marcus
28 января 2016 в 22:05
0

Если вы просто перестанете использовать == и будете использовать ===, тогда это решит проблему if (s === "").

avatar
Andron
8 мая 2013 в 17:15
10

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

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

Bennett McElwee
1 апреля 2014 в 22:44
2

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

Andron
2 апреля 2014 в 11:24
0

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

Bennett McElwee
2 апреля 2014 в 21:15
0

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

Andron
3 апреля 2014 в 12:14
0

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

Bennett McElwee
3 апреля 2014 в 22:57
0

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

avatar
GibboK
10 февраля 2013 в 10:20
2

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

var myString = 'hello'; 
if(myString.charAt(0)){
    alert('no empty');
}
alert('empty');
avatar
Yang Dong
9 января 2013 в 02:54
37

Попробуйте:

if (str && str.trim().length) {  
    //...
}
frogcoder
22 ноября 2017 в 04:57
2

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

devildelta
6 марта 2019 в 06:32
0

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

Stephen M Irving
8 января 2020 в 19:10
0

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

avatar
dkinzer
18 декабря 2012 в 22:31
3

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

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

TestMe();

var str = 'hello';

TestMe();

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

avatar
Bikush
31 июля 2012 в 14:05
11

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

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

cartbeforehorse
20 октября 2012 в 12:20
2

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

avatar
mricci
19 июля 2012 в 02:00
8

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

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

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

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

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

Flimm
11 августа 2021 в 15:23
0

Здесь вы проверяете достоверность, что немного сложнее, чем простая проверка пустых строк, undefined или null.

avatar
Will
1 июня 2011 в 15:40
11

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

function isBlank(pString) {
    if (!pString) {
        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);
}
Nicholi
27 октября 2011 в 21:49
3

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

Will
5 июля 2021 в 15:06
2

Я видел этот комментарий только десять лет спустя. Но да, вы правы, обновлю. :)

Nicholi
6 июля 2021 в 16:16
1

Объединяя наши знания 1 десятилетие за раз :)

Will
17 июля 2021 в 00:53
0

@Nicholi, увидимся в 2031 году!

avatar
karthick.sk
30 марта 2011 в 13:34
415

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

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

Или используйте приведение типа:

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

Оба выполняют одну и ту же функцию. Приведите переменную к типу Boolean, где str - это переменная.

  • Он возвращает false для null, undefined, 0, 000, "", false.

  • Он возвращает true для всех строковых значений, кроме пустой строки (включая такие строки, как "0" и " ")

Mene
3 апреля 2011 в 13:04
81

Почему это «даже лучше»?

Bluebaron
3 августа 2014 в 16:57
2

Это неприятный трюк, это так, как надо. Это правильный путь. Javascript определяет истинность "" и null как ложь.

Peter Olson
19 декабря 2014 в 18:28
42

Есть ли разница между поведением if(str) и if(!!str)?

John Ruddell
10 марта 2015 в 23:00
7

@PeterOlson, если вы пытаетесь сохранить переменную как логическое значение, которое проверяет несколько строк на предмет содержимого, тогда вы захотите сделать это .. иначе обработка var any = (!!str1 && !!str2 && !!str3), если там есть число

Dario Oddenino
11 февраля 2016 в 10:56
35

Я всегда использую это решение. !!str.trim(), чтобы строка не состояла только из пробелов.

shinzou
17 октября 2016 в 21:28
16

Не похоже на хакерство, Boolean(str) намного читабельнее и менее "чушь".

xehpuk
15 марта 2017 в 11:44
1

@JohnRuddell Это не ответ на вопрос Питера, и это не похоже на то, что я хотел бы делать.

John Ruddell
15 марта 2017 в 18:05
2

@xehpuk не уверен, что понимаю, что вы имеете в виду. оператор не не применяет логический тип .. также известный как истина или ложь. Если вы хотите принудительно использовать логический тип, используйте оператор not not. По сути, при проверке if между ними нет разницы. Но это особенно полезно, когда вам нужен логический флаг, который вы используете более чем в одном месте. Это то, о чем идет речь в моем комментарии, хотя это прямо не указано.

xehpuk
15 марта 2017 в 19:34
0

@JohnRuddell Да, поэтому этот ответ не очень полезен. А для логической переменной почему не var any = Boolean(str1 && str2 && str3);? Должно быть четче и быстрее.

John Ruddell
16 марта 2017 в 19:05
0

@xehpuk нет, это совсем не быстрее. вы должны посмотреть, что делает Boolean

xehpuk
16 марта 2017 в 19:12
1

@JohnRuddell Boolean(value) преобразует любое значение в логическое значение. Простой. !! преобразует любое значение в логическое значение и дважды его инвертирует.

John Ruddell
17 марта 2017 в 00:28
1

@xehpuk Вы не понимаете преимущества !!. Boolean - это класс javascript. У него есть множество методов. Когда вы используете Boolean в качестве функции, вы по-прежнему выделяете память для всех ее методов, а также для его части базового класса. Это сложнее, чем простая логическая проверка оператора, поэтому !! более эффективен.

John Ruddell
17 марта 2017 в 04:22
0

@xehpuk Boolean - это примитивный тип .. когда вы вызываете Boolean(something), вы вызываете функцию конструктора, которая соответствует примитивному типу Boolean ... (иначе говоря, без использования ключевого слова new), чтобы явно привести значение как истинное или ложный (за исключением того, что он возвращает логический объект, а не истинное логическое значение ... Если вы посмотрите на объявление MDN, что такое логическое значение, вы можете довольно легко увидеть, что он делает. но это в стороне ссылка, которая сравнивает скорость между Boolean и !! sitepoint.com/javascript-double-negation-trick-trouble

Oliver Spryn
14 апреля 2017 в 17:27
4

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

Lluis Martinez
20 июня 2018 в 14:11
0

Похоже на взлом

FranCarstens
24 августа 2018 в 15:10
0

@Lluis Martinez, разборчивый, современный JS; было бы еще лучше, если бы OP написал: const someFunc = () => {}; !!str && someFunc()

Lluis Martinez
27 августа 2018 в 08:41
1

Современный JS - несомненно. Разборчивость - дело вкуса. Для меня это не так :-)

rasso
20 марта 2019 в 08:32
2

!! Bang Bang, ты логический !!

Arth
30 мая 2019 в 09:17
0

@JohnRuddell разве не лишняя челка в var any = (!!str1 && !!str2 && !!str3)? Не преобразует ли оператор && операнды в логические значения?

John Ruddell
30 мая 2019 в 15:03
0

@arth вы можете это сделать, это зависит от вашего стиля кода. Когда я выполняю логическую проверку, мне нравится приводить к логическому типу через !!, чтобы обеспечить согласованное поведение ... когда вы не имеете дело с логическими значениями, реализация браузеров потенциально может вести себя иначе.

Arth
31 мая 2019 в 08:27
0

@JohnRuddell Почему неявное преобразование переменной в логическое значение в браузере зависит от! оператор и оператор &&? .. а если да, то почему верить одному, а не другому?

Alvin Thompson
27 августа 2019 в 17:10
1

@Arth @JohnRuddell: нет, челка не лишняя. Например, 'aa' && 'ddd' возвращает 'ddd', а не true. 'ddd' в дальнейшем вычисляется как true, поэтому вы можете использовать только 'aa' && 'ddd' как есть в операторе if. Но если вы присваиваете результат логическому значению, челка необходима.

Alvin Thompson
27 августа 2019 в 17:24
1

@JohnRuddell @Arth: другими словами, && javascript не возвращает логическое значение, если только выбранный операнд не является логическим. Вот определение его поведения (для expr1 && expr2): «Если expr1 можно преобразовать в true, возвращает expr2; иначе возвращает expr1».

Arth
28 августа 2019 в 08:42
0

@AlvinThompson Ах да, я пропустил это .. спасибо, хороший момент! При назначении логической переменной необходимо явное преобразование, но вместо этого оно может быть выполнено как !!(str1 && str2 && str3) или Boolean(str1 && str2 && str3). Если не назначать, явное преобразование излишне, достаточно if (str1 && str2 && str3){} ..

Alex
25 марта 2020 в 09:09
0

Это хорошо, поскольку позволяет не использовать свойство .length, которое существует в Array и String.

Alexandre Piva
18 июля 2020 в 14:23
0

@Mene Это лучше, потому что, если передается неопределенная переменная, возвращаемое значение будет undefined вместо логического false, а оно будет коротким и легким для понимания.

Oli Crt
8 сентября 2020 в 09:03
5

Это просто бесполезно в if, оно преобразует ложные значения в false, а истинные значения в true. Блок if либо выполняется, либо не выполняется в зависимости от того, является ли выражение истинным, нет смысла добавлять !!

sean
10 декабря 2020 в 12:17
1

Для тех, кому интересно: 1. Boolean(expr) - это то же самое, что !!expr 2. Boolean(expr) внутри if бесполезно; if уже неявно приводит выражение, указанное внутри него. Это может стать неожиданностью, например, для тех, кто работает с C #.

Vladyn
28 января 2021 в 11:10
0

Действительно аккуратно! Спасибо!

James
25 марта 2021 в 13:32
0

«0», «00» и т. Д. Являются допустимыми значениями. Все, что нужно большинству людей, - это знать, есть ли значение или нет, которое по большей части не определено, равно нулю и т. Д.

avatar
Muhammad Salman
6 августа 2010 в 16:28
4
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' />

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

avatar
Doug
22 июля 2010 в 15:30
7

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

str.value.length == 0
AndFisher
14 декабря 2016 в 10:57
6

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

alexandre-rousseau
11 сентября 2019 в 07:08
2

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

avatar
Jano González
16 июля 2010 в 01:45
1277

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

function isEmpty(str) {
    return (!str || str.length === 0 );
}

(Обратите внимание, что строки - не единственные переменные с атрибутом length, например, массивы также имеют их.)

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

function isBlank(str) {
    return (!str || /^\s*$/.test(str));
}

Если хотите, вы можете monkey-patch прототип String следующим образом:

String.prototype.isEmpty = function() {
    // This doesn't work the same way as the isEmpty function used 
    // in the first example, it will return true for strings containing only whitespace
    return (this.length === 0 || !this.trim());
};
console.log("example".isEmpty());

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

Vincent
23 сентября 2013 в 08:11
41

почему 0 === str.length вместо str.length === 0?

florian
23 сентября 2013 в 09:58
107

Условия @Vincent часто записываются так: if (variable == constant value), и если вы забыли знак «=», то вместо тестирования вы присваиваете переменной постоянное значение. Код по-прежнему будет работать, поскольку вы можете назначить переменную в if. Таким образом, более безопасный способ записать это условие - поменять местами постоянное значение и переменную. Таким образом, при тестировании кода вы увидите ошибку (неверная левая сторона в назначении). Вы также можете использовать что-то вроде JSHint, чтобы запретить присваивание в условиях и получать предупреждение, когда вы его напишете.

florian
23 сентября 2013 в 10:01
0

Я забыл упомянуть, что, поскольку вы в основном используете '===' или '! ==', вы меньше подвержены подобным ошибкам.

Adrien Be
15 июля 2014 в 11:33
2

позор, что /^\s*$/.test(str) на самом деле не читается - может быть, лучше удалить пробелы с помощью более простого кода или регулярного выражения? см. coderhelper.com/questions/6623231/…, а также coderhelper.com/questions/10800355/…

khebbie
28 ноября 2014 в 08:06
0

Мне это нравится, и я добавил это в прототип String String.prototype.isEmpty = function () {return (! This || 0 === this.length); };

Schadenfreude
19 июня 2015 в 12:35
9

/^\s*$/.test(str) можно заменить на str.trim (). length === 0

AZ.
26 января 2016 в 00:12
40

@Vincent, это также называется «Условия Йоды», например if blue is the sky. См. dodgycoder.net/2011/11/yoda-conditions-pokemon-exception.html

Harsh Pandey
11 июня 2019 в 19:29
2

Чем return (this.length === 0 || !this.trim()) лучше, чем просто return !this.trim()?

g-moniava
15 июля 2019 в 12:18
1

@Jano Gonzales Почему бы в первой версии просто не использовать function isEmpty(str) { return !str; }?

Stephen M Irving
8 января 2020 в 18:55
1

На самом деле не стоит расширять собственные прототипы, это обычно считается плохой практикой, когда многие люди просто рекомендуют не делать этого полностью, поскольку есть более безопасные способы, которые не менее хороши. Есть обсуждение 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 }

Flimm
11 августа 2021 в 15:12
0

Пустые строки неверны, поэтому вторая часть условия на самом деле не нужна: (! str || str.length == 0)

avatar
Jet
9 июля 2010 в 18:52
68

Я использую:

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
Jeff Davis
20 апреля 2012 в 13:11
5

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

xarlymg89
25 января 2018 в 10:06
2

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

Lucas
17 апреля 2018 в 11:15
0

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

beeThree
25 февраля 2020 в 03:01
1

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

Boris J.
27 марта 2020 в 19:34
0

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

Sebastian Simon
2 июля 2021 в 00:54
0

case typeof(e) == "undefined": неверно; который соответствует e из false, а не из undefined. Очевидно, это было предложенное изменение, которое было одобрено. Исходный case typeof this == "undefined": по-прежнему не имеет смысла. Также нет причин считать false, 0 и "0" «пустыми».

Joseph Hamilton
4 августа 2021 в 18:26
0

Просто идет, чтобы показать, насколько смехотворен этот красивый язык :(

Flimm
11 августа 2021 в 14:57
0

Эта функция возвращает истину для isEmpty("0"), что для меня является неожиданным и нежелательным поведением. В Javascript "0" оценивается как истина в логических контекстах, поэтому я не ожидал, что он будет считаться пустым.

avatar
oem
31 мая 2010 в 14:57
21

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

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

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

Orpheus
11 мая 2015 в 16:38
1

Это работает, но это ужасно дорого с точки зрения эксплуатации. Хорошо, если вы хотите просто проверить одну или две вещи, а не большой набор.

avatar
jmc734
15 февраля 2010 в 02:46
6

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

if (str == "") {
     //Do Something
}
else {
     //Do Something Else
}
alexandre-rousseau
11 сентября 2019 в 07:05
4

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

avatar
Sugendran
30 сентября 2008 в 23:08
109

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

if(str.replace(/\s/g,"") == ""){
}
flash
22 октября 2010 в 10:02
8

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

driAn
11 ноября 2010 в 13:57
4

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

mpen
20 июня 2011 в 04:29
28

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

neezer
27 июня 2011 в 15:04
34

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

Marecky
7 марта 2012 в 23:58
1

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

Luke101
5 июля 2012 в 17:30
1

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

vhanla
17 сентября 2012 в 23:23
0

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

Darryl
14 сентября 2014 в 20:55
5

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

Ates Goral
7 декабря 2016 в 20:19
2

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

avatar
Ates Goral
30 сентября 2008 в 19:17
122

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

if (!str.length) { ...
Pic Mickael
11 сентября 2018 в 13:50
22

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

Ates Goral
12 сентября 2018 в 03:25
7

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

Flimm
11 августа 2021 в 15:15
0

Обратите внимание, что строки - не единственный тип переменных, у которых есть атрибут length. Массивы тоже.

avatar
cllpse
30 сентября 2008 в 17:42
38
var s; // undefined
var s = ""; // ""
s.length // 0

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

Flimm
11 августа 2021 в 15:17
0

Я не понимаю это предложение: There's nothing representing an empty string in JavaScript. . А как насчет "", разве это не пустая строка?

avatar
Chris Noe
30 сентября 2008 в 17:20
31

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

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

Constantin
30 сентября 2008 в 19:21
11

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

Useless Code
13 июня 2015 в 17:52
5

Я согласен с тем, что прояснение вашего намерения важнее, чем любые микрооптимизации, которые могут дать другие методы, но использование оператора строгого сравнения === было бы лучше. Он возвращает истину, только если strVar - пустая строка.

Valentin Heinitz
27 декабря 2015 в 13:57
0

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

Scott Marcus
28 января 2016 в 22:02
4

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

Brent Bradburn
18 января 2018 в 21:19
1

Какой оператор равенства (== vs ===) следует использовать при сравнении JavaScript?