如何在 JavaScript 中检查空/未定义/空字符串？

Question

JavaScript 中是否有 string.Empty，或者只是检查 "" 的情况？

Answer 1

我用：

function empty(e) {
  switch (e) {
    case "":
    case 0:
    case "0":
    case null:
    case false:
    case undefined:
      return true;
    default:
      return false;
  }
}

empty(null) // true
empty(0) // true
empty(7) // false
empty("") // true
empty((function() {
    return ""
})) // false

Answer 2

性能

我在 macOS v10.13.6 (High Sierra) 上对 18 个选定的解决方案进行了测试。 解决方案的工作方式略有不同（对于极端情况输入数据），如下面的代码片段所示。

结论

• 基于!str、==、===和length 对于所有浏览器（A、B、C、G、I、J）都很快
• 基于正则表达式（test、replace）和 的解决方案charAt 对于所有浏览器（H、L、M、P）来说都是最慢的，
• 标记为最快的解决方案仅在一次测试运行中是最快的 - 但在许多运行中，它在“快速”解决方案组内发生了变化

详细信息

在下面的代码片段中，我通过使用不同的输入参数来比较所选 18 种方法的结果

• "" "a" " "- 空字符串，带字母的字符串和带空格的字符串
• [] {} f - 数组、对象和函数
• 0 1 NaN Infinity - 数字
• true false - 布尔
• null <代码>未定义

并非所有测试方法都支持所有输入情况。

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

然后，对于所有方法，我都会针对 Chrome v78.0.0、Safari v13.0.4 和 Firefox v71.0.0 浏览器执行速度测试用例 str = "" - 您可以在您的计算机上运行测试 此处

Answer 3

前面的所有答案都很好，但这个会更好。 使用双 NOT 运算符 (!!)：

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

或使用类型转换：

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

两者执行相同的功能。 将变量类型转换为布尔值，其中 str 是一个变量。

• 对于 null、undefined、0、000、 “”，假。

• 对于除空字符串之外的所有字符串值（包括 "0" 和 " " 等字符串），它返回 true

  >

Answer 4

您可以得到的最接近 str.Empty （前提是 str 是一个字符串）是：

if (!str.length) { ...

Answer 5

如果您需要确保字符串不仅仅是一堆空格（我假设这是用于表单验证），您需要对空格进行替换。

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

Answer 6

空字符串、未定义、null、...

检查真实值：

if (strValue) {
    // strValue was non-empty string, true, 42, Infinity, [], ...
}

检查 falsy 值：

if (!strValue) {
    // strValue was empty string, false, 0, null, undefined, ...
}

---

空字符串（仅限！）

要检查是否为空字符串，请使用 进行严格相等比较/Operators/Strict_equality" rel="noreferrer">=== 运算符：

if (strValue === "") {
    // strValue was empty string
}

要严格检查是否为空字符串，请使用 !== 运算符：

if (strValue !== "") {
    // strValue was not an empty string
}

Answer 7

用于检查变量是否 falsey 或者它的长度属性是否等于零（对于字符串来说，意味着它是空的），我使用：

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

_{(请注意，字符串不是唯一具有 length 属性的变量，例如，数组也有它们。 )}

或者，您可以使用（不是这样）新的可选链接和箭头函数来简化：

const isEmpty = (str) => (!str?.length);

它将检查长度，如果值为 null，则返回 undefined，而不会引发错误。 在空值的情况下，零是假的，结果仍然有效。

为了检查变量是否为 false 或者字符串是否仅包含空格或为空，我使用：

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

_{请注意，monkey-patching 内置类型是有争议的，因为它无论出于何种原因，都可以破坏依赖于内置类型的现有结构的代码。}

Answer 8

非常通用的“一体化”函数（但不推荐）：

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

但是，我不建议使用它，因为您的目标变量应该是特定类型（即字符串或数字，或对象？），因此应用与该变量相关的检查。

Answer 9

您可以使用 lodash：
_.isEmpty(值)。

它涵盖了很多情况，例如 {}、''、null、undefined 等。

但它总是对于 JavaScript 原始数据类型，如 _.isEmpty(10) 或 _.isEmpty(Number.MAX_VALUE) 均返回 true。

Answer 10

尝试：

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

Answer 11

我不会太担心最有效的方法。 使用最符合您意图的内容。 对我来说，通常是 strVar == ""。

根据 Constantin 的评论，如果 strVar 可能最终包含一个整数 0 值，那么这确实是 1那些澄清意图的情况。

Answer 12

if ((input?.trim()?.length || 0) > 0) {
   // input 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;

说明：

如果 input 为 undefined 或 null 则 null 合并 ?. 将导致input?.trim()?.length 将为 undefined 或 null。 与 0 进行或运算 (||) 将得到 0。 0 不是 > 0 因此结果将为 false，即它是一个 nil 值。

如果 input 为空或空格，则 .trim() 将删除前导和结尾空格，这将使空输入保持不变，并将任何空格转换为空值。 那么空字符串的长度就是0，并且如上，0并不是>0。 0，因此结果将为false，即它是空的或只有空格。

如果input是任何其他字符串，它的长度将> 0 在调用 .trim() 后，因此结果将为 true，即它不是 nil 值，也不是空值或只有空格。

Answer 13

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

JavaScript 中没有任何东西代表空字符串。 检查 length （如果您知道 var 始终是字符串）或 ""

Answer 14

这里有很多有用的信息，但在我看来，最重要的元素之一没有得到解决。

null、undefined 和 "" 都是 falsy。

当评估空字符串时，通常是因为您需要用其他东西替换它。

在这种情况下，您可能会出现以下行为。

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

请注意，您可能还想 trim() 字符串，因为 "" !== " "。

Answer 15

同时，我们可以有一个函数来检查所有“空”，例如 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

Answer 16

我对如果将非字符串和非空/空值传递给测试器函数会发生什么进行了一些研究。 正如许多人所知， (0 == "") 在 JavaScript 中是正确的，但由于 0 是一个值而不是空或 null，因此您可能需要测试它。

以下两个函数仅对于未定义、null、空/空白值返回 true，对于其他所有值（例如数字、布尔值、对象、表达式等）返回 false。

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

存在更复杂的示例，但这些示例很简单并且给出一致的结果。 无需测试未定义，因为它包含在 (value == null) 检查中。 您还可以通过将它们添加到 String 来模仿 C# 行为，如下所示

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

Answer 17

1. 检查var a;是否存在

2. 删除值中的错误空格，然后测试是否为空

    if ((a)&(a.trim()!='')) 
      { 
        // 如果变量a不为空则执行此操作  
      } 
     

Answer 18

我通常使用这样的东西，

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

Answer 19

另外，如果您将空格填充的字符串视为“空”。

您可以使用以下正则表达式来测试它：

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

Answer 20

如果不仅需要检测空字符串，还需要检测空字符串，我将添加到 Goral 的答案中：

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

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

Answer 21

从以下开始：

return (!value || value == undefined || value == "" || value.length == 0);

查看最后一个条件，如果 value == ""，则其长度必须为0。因此丢弃它：

return (!value || value == undefined || value == "");

但是等等！ 在 JavaScript 中，空字符串为 false。 因此， drop value == "":

return (!value || value == undefined);

并且 !undefined 为 true，因此不需要检查。 所以我们有：

return (!value);

我们不需要括号：

return !value

Answer 22

我使用组合，最快的检查是最先的。

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

Answer 23

我没有注意到考虑到字符串中空字符可能性的答案。 例如，如果我们有一个空字符串：

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 空字符或空白字符（即不间断空格、字节顺序标记、行/段落分隔符等）。

Answer 24

您还可以使用正则表达式：

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

检查是否为空或填充空格的字符串。

Answer 25

很多答案，还有很多不同的可能性！

毫无疑问，对于快速而简单的实现，获胜者是： 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;
}

我知道，有点过分了。

Answer 26

我在这里没有看到一个好的答案（至少没有一个适合我的答案）

所以我决定回答自己：

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

您需要开始检查它是​​否未定义。 否则你的方法可能会爆炸，然后你可以检查它是否等于 null 或者等于空字符串。

你不能有！ 或仅 if(value) 因为如果您检查 0 它会给您一个错误的答案（0 是错误的）。

话虽如此，将其包装在如下方法中：

public static isEmpty(value: any): boolean {
返回值===未定义|| 值 === null || 值===“”；
PS

.: 你不需要检查 typeof，因为它甚至在进入方法之前就会爆炸并抛出

Answer 27

尝试这个：

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

Answer 28

所有这些答案都很好。

但我不能确定该变量是一个字符串，不仅仅包含空格（这对我来说很重要），并且可以包含“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 上的示例。

Answer 29

使用空合并运算符修剪空白：

if (!str?.trim()) {
  // do something...
}

Answer 30

没有 isEmpty() 方法，您必须检查类型和长度：

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

需要进行类型检查，以避免当 test 未定义时出现运行时错误 或 null。