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

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

4774335 次浏览
小开
最佳答案

空字符串，未定义，空，…

要检查真值：

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

要检查假值：

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

空字符串（仅限！）

要检查空字符串是否准确，请使用#1操作员将严格相等性与""进行比较：

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

要严格检查不是空字符串，请使用#0运算符：

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

我不会太担心最重要的方法。使用最清楚你意图的方法。对我来说，这通常是0。

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

小开 
var s; // undefinedvar s = ""; // ""s.length // 0

JavaScript中没有表示空字符串的内容。对length（如果您知道var将始终是字符串）或""进行检查

小开

最接近str.Empty（前提是str是字符串）的是：

if (!str.length) { ...
小开

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

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

我通常使用这样的东西：

if (str == "") {//Do Something}else {//Do Something Else}
小开

你也可以使用正则表达式：

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

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

小开

我使用：

function empty(e) {switch (e) {case "":case 0:case "0":case null:case false:case undefined:return true;default:return false;}}
empty(null) // trueempty(0) // trueempty(7) // falseempty("") // trueempty((function() {return ""})) // false
小开

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

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

（请注意，字符串不是唯一具有length属性的变量，例如数组也有它们。）

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

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

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

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

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

如果你愿意，你可以像这样猴斑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 whitespacereturn (this.length === 0 || !this.trim());};console.log("example".isEmpty());

请注意，对内置类型进行猴子修补是有争议的，因为无论出于何种原因，它都可能破坏依赖于内置类型的现有结构的代码。

小开

试试这个

str.value.length == 0
小开 
function tell(){var pass = document.getElementById('pasword').value;var plen = pass.length;
// Now you can check if your string is empty as likeif(plen==0){alert('empty');}else{alert('you entered something');}}
<input type='text' id='pasword' />

这也是检查字段是否为空的通用方法。

小开

前面所有的答案都很好，但这会更好。使用对偶非运算符（!!）：

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

或者使用类型转换：

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

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

  • 它返回falsenull，undefined，0，000，""，false。

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

小开

我使用组合，最快的检查是第一个。

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 stringreturn !/[^\s]+/.test(pString);}
小开

忽略空白字符串，您可以使用它来检查null、空和未定义：

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

它简洁，适用于未定义的属性，尽管它不是最具可读性的。

小开

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

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

小开

检查您是否尝试传递未定义的术语也是一个好主意。

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

当对象实例的字符串属性不为空时，我通常会遇到我想做某事的情况。这很好，除了该属性并不总是存在。

小开

尝试：

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

另一种方式，但我相信bdukes的回答是最好的。

var myString = 'hello';if(myString.charAt(0)){alert('no empty');}alert('empty');
小开

所有这些答案都很好。

但是我不能确定变量是一个字符串，不只包含空格（这对我来说很重要），并且可以包含“0”（字符串）。

我的版本：

function empty(str){return !str || !/[^\s]+/.test(str);}
empty(null); // trueempty(0); // trueempty(7); // falseempty(""); // trueempty("0"); // falseempty("  "); // true

jsfiddle上的样本。

小开

我做了一些研究，如果将非字符串和非空/null值传递给测试函数会发生什么。正如许多人所知，（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-class的实例为null，它会出错：

String.prototype.IsNullOrEmpty = function (value) { ... }var myvar = null;if (1 == 2) { myvar = "OK"; } // Could be setmyvar.IsNullOrEmpty(); // Throws error

我使用以下值数组进行了测试。如果有疑问，您可以循环它来测试您的函数。

// Helper itemsvar 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; } }]];
小开

此外，如果您认为空格填充的字符串为“空”。

你可以用这个正则表达式来测试它：

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

我更喜欢使用非空白测试而不是空白 

function isNotBlank(str) {return (str && /^\s*$/.test(str));}
小开

不要假设您检查的变量是一个字符串。不要假设如果这个var有一个长度，那么它就是一个字符串。

问题是：仔细考虑你的应用程序必须做什么和可以接受什么。构建一些健壮的东西。

如果你的方法/函数应该只处理非空字符串，那么测试参数是否为非空字符串，不要做一些“技巧”。

作为一个例子，如果你不小心遵循这里的一些建议，就会爆炸。

var getLastChar = function (str) {if (str.length > 0)return str.charAt(str.length - 1)}
getLastChar('hello')=> "o"
getLastChar([0,1,2,3])=> TypeError: Object [object Array] has no method 'charAt'

所以，我坚持

if (myVar === '')...
小开

我通常用这样的东西，

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

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

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

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

小开 
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")}
小开

你也应该始终检查类型，因为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");}

小开

检查它是否为空：

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

检查它是否为string类型：

var str = "Hello World!";if(typeof(str) === 'string'){alert("This is a String");}
小开

如果一个人不仅需要检测空字符串，还需要检测空字符串，我将添加到戈拉尔的回答中：

function isEmpty(s){return !s.length;}
function isBlank(s){return isEmpty(s.trim());}
小开
  1. 检查var a;是否存在

  2. 修剪值中的false spaces，然后测试emptiness

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

Underscore.js JavaScript库http://underscorejs.org/提供了一个非常有用的_.isEmpty()函数，用于检查空字符串和其他空对象。

参考：http://underscorejs.org/#isEmpty

是否为空_.isEmpty(object)
如果可枚举对象不包含任何值（没有可枚举的自属性），则返回true。对于字符串和类似数组的对象_. is空检查长度属性是否为0。

_.isEmpty([1, 2, 3]);
=>false

_.isEmpty({});
=>true

其他非常有用的Underscore.js功能包括：

小开

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

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

有点过分，我知道。

小开

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

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

当test是undefined或null时，需要类型检查以避免运行时错误。

小开

您可以使用豆沙：_. is空（值）。

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

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

小开

您可以轻松地将其添加到javascript中的本机String对象中，并一遍又一遍地重复使用它…
如果你想检查''空字符串，下面的代码可以为你做这项工作：

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
小开

您可以验证以下方法并了解其中的区别。

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

小开

同时，我们可以有一个函数来检查所有的“空”，比如null，未定义, '', ' ', {}, []。所以我写了这个。

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()); // trueconsole.log(isEmpty(null)); // trueconsole.log(isEmpty('')); // trueconsole.log(isEmpty('  ')); // trueconsole.log(isEmpty(undefined)); // trueconsole.log(isEmpty({})); // trueconsole.log(isEmpty([])); // trueconsole.log(isEmpty(0)); // falseconsole.log(isEmpty('Hey')); // false
小开

试试这个：

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

以下正则表达式是另一种解决方案，可用于空、空或未定义的字符串。

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

我添加了这个解决方案，因为它可以进一步扩展以检查空或某些值，如以下所示。以下正则表达式正在检查字符串可以为空null未定义或仅包含整数。

(/(null|undefined|^$|^\d+$)/).test()
小开

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

所以我决定自己回答：

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

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

你不能有！！或者只有if(value)，因为如果你选中0，它会给你一个错误的答案（0是错误的）。

话虽如此，把它包装在一个方法中，比如：

public静态值为空（value： any）： boolean{返回值===未定义||值===null||值 === "";

PS：你不需要检查类型，因为它在进入方法之前就会爆炸并抛出

小开

性能

我在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-数组、对象和函数
  • 01NaNInfinity-数字
  • truefalse-Boolean
  • nullundefined

并非所有测试的方法都支持所有输入用例。

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 = ""浏览器Chromev78.0.0，Safariv13.0.4，和Firefox v71.0.0-您可以在您的机器上运行测试这里

在此处输入图片描述

小开

开始于：

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

查看最后一个条件，如果value == "", 它的长度必须为0。因此删除它：

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

但是等等！在JavaScript中，空字符串是false。因此，删除值 == "":

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

并且！undefault是true，所以不需要检查。所以我们有：

return (!value);

我们不需要括号：

return !value
小开 
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;
小开

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

null、undefined和""都是Falsy。

在计算空字符串时，通常是因为您需要用其他东西替换它。

在这种情况下，您可以期待以下行为。

var a = ""var b = nullvar 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 falsevalidStr(null) // returns falsevalidStr("") // returns falsevalidStr("My String") // returns true
小开

使用null合并运算符修剪空格：

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

您可以使用typeof运算符和长度方法来检查这一点。

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

检查这个最简单的函数是…

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

用法：

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

就是这么简单：）

小开

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));}
// testsconsole.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"));

小开

试试这个代码：

function isEmpty(strValue){// Test whether strValue is emptyif (!strValue || strValue.trim() === "" ||(strValue.trim()).length === 0) {// Do something}}
小开

这是一个false sy值。

第一种解决方案：

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

第二种解决方案：

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

第三种解决方案：

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

以下是我用于处理此问题的一些自定义函数。以及代码如何运行的示例。

const v1 = 0const v2 = '4'const v2e = undefinedconst v2e2 = nullconst v3 = [1, 2, 3, 4]const v3e = []const v4 = trueconst v4e = falseconst 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的来源是空的：

小开

检查它是否为string类型，如果它不为空：

const isNonEmptyString = (val) => typeof val === 'string' & !!val

提交答案