如何在JavaScript中检查empty / undefined / null字符串？

时间：2008-09-30 17:17:45

标签： javascript null is-empty

我看到了thread，但我没有看到JavaScript特定的示例。 JavaScript中是否有简单的string.Empty，或仅仅是检查""的情况？

57 个答案:

答案 0 :(得分：3089)

如果您只是想检查是否有值，可以

if (strValue) {
    //do something
}

如果您需要专门检查空字符串是否为null，我认为使用the === operator检查""是最好的选择（这样您就知道它实际上是你正在比较的字符串。）

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

答案 1 :(得分：996)

为了检查字符串是否为空，null或未定义，我使用：

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

为了检查字符串是否为空，null或未定义，我使用：

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

检查字符串是否为空或仅包含空格：

String.prototype.isEmpty = function() {
    return (this.length === 0 || !this.trim());
};

答案 2 :(得分：255)

以上所有都很好，但这会更好。使用!!（不是）运算符。 

if(!!str){
some code here;
}

或使用类型转换：

if(Boolean(str)){
    codes here;
}

两者都做同样的函数，输入变量为boolean，其中str是变量 false返回null,undefined,0,000,"",false 返回true表示字符串“0”和空格“”。

答案 3 :(得分：95)

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

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

答案 4 :(得分：88)

你最接近str.Empty（前提是str是一个字符串）是：

if (!str.length) { ...

答案 5 :(得分：54)

我用：

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

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

答案 6 :(得分：31)

功能：

function is_empty(x)
{
   return ( 
        (typeof x == 'undefined')
                    ||
        (x == null) 
                    ||
        (x == false)  //same as: !x
                    ||
        (x.length == 0)
                    ||
        (x == "")
                    ||
        (x.replace(/\s/g,"") == "")
                    ||
        (!/[^\s]/.test(x))
                    ||
        (/^\s*$/.test(x))
  );
}
  

P.S。在Javascript中，请勿在{{1​​}};

之后使用换行符

答案 7 :(得分：31)

尝试：

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

答案 8 :(得分：28)

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

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

答案 9 :(得分：26)

我不会过分关注最强高效方法。使用最明确的意图。对我而言，通常是strVar == ""。

编辑：来自Constantin的评论，如果strVar可能会有一些结果包含整数0值，那么这确实是那些意图澄清情况之一。

答案 10 :(得分：26)

您可以使用lodash： _.isEmpty（值）。

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

但true Number类_.isEmpty(10)总是返回_.isEmpty(Number.MAX_VALUE)，true或Range两者都返回FindNext。

答案 11 :(得分：19)

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

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

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

答案 12 :(得分：17)

很多答案，以及很多不同的可能性！

毫无疑问，快速简单的实施方案是：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;
    }
}

有点过分，我知道。

答案 13 :(得分：16)

  1. 检查var a;是否存在

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

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

答案 14 :(得分：14)

另外，如果您将填充空格的字符串视为“空”。 您可以使用此正则表达式进行测试：

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

答案 15 :(得分：12)

开始于：

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

查看最后一个条件，如果value ==“”，则其长度必须为0。因此将其删除：

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

但是等等！在JavaScript中，空字符串为false。因此，放置值==“”：

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

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

return (!value);

我们不需要括号：

return !value

答案 16 :(得分：11)

我经常使用这样的东西，

if (!str.length) {
//do some thing
}

答案 17 :(得分：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
}

答案 18 :(得分：9)

如果一个人不仅要检测空字符串还需要空白字符串，我会添加Goral的答案：

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

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

答案 19 :(得分：9)

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

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

答案 20 :(得分：8)

所有这些答案都很好。

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

答案 21 :(得分：7)

忽略空白字符串，您可以使用它来检查null，empty和undefined：

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

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

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

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

答案 22 :(得分：7)

检查是否完全是空字符串：

if(!val)...

检查它是否为空字符串或无值的逻辑等效项（null，undefined，0，NaN，false，...）：

data=

Entry No | Time        | Word
---------|-------------|-------
1        | 000:123:456 | 0123  
2        | 000:123:457 | A0A0
3        | 000:123:543 | F0F0
4        | 000:124:123 | FFA0
5        | 000:124:987 | 2A0F


Msg = find(strcmp('F0F0', data.Col));

Msg = find(ismember(data.Col,'F0F0')); 

Msg = strfind(data.Col, 'F0F0');

Msg = data(data{:, 20} == F0F0,:);

答案 23 :(得分：7)

我通常使用类似的东西：

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

答案 24 :(得分：7)

与此同时，我们可以使用一个函数来检查所有'空虚'，例如 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

答案 25 :(得分：7)

我使用组合，最快速检查。

function isBlank(pString){
    if (!pString || pString.length == 0) {
        return true;
    }
    // checks for a non-white space character 
    // which I think [citation needed] is faster 
    // than removing all the whitespace and checking 
    // against an empty string
    return !/[^\s]+/.test(pString);
}

答案 26 :(得分：7)

我做了一些研究，如果将非字符串和非空/空值传递给测试器函数会发生什么。众所周知，（0 ==“”）在javascript中是正确的，但由于0是一个值而不是空或null，您可能想要测试它。

以下两个函数仅对undefined，null，empty / whitespace值返回true，对其他所有值返回false，如数字，布尔值，对象，表达式等。

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

存在更复杂的例子，但这些例子很简单并且给出了一致的结果。没有必要测试undefined，因为它包含在（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 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 js
    ['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; } }]
];

答案 27 :(得分：6)

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;

答案 28 :(得分：6)

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

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

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

答案 29 :(得分：5)

我在这里没有找到好的答案（至少不是适合我的答案） 所以我决定回答自己：

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

您需要开始检查它是​​否未定义，否则您的方法会爆炸，而不是检查是否等于null或等于空字符串

你不能拥有！或仅if(value)，因为如果您选中0，它将给您一个错误的答案（0为错误）

如上所说，用如下方法包装起来：

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

PS。 您不需要检查typeof ，因为它甚至在进入方法之前都会爆炸。

答案 30 :(得分：5)

您可以轻松地将其添加到 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

答案 31 :(得分：5)

试试这个

str.value.length == 0

答案 32 :(得分：5)

不要假设您检查的变量是字符串。不要假设如果这个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 === '')
  ...

答案 33 :(得分：4)

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

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

  

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

     

_.isEmpty([1, 2, 3]);
   =＆GT;假

     

_.isEmpty({});
  =＆GT;真

其他非常有用的下划线功能包括：
http://underscorejs.org/#isNull _.isNull(object)
http://underscorejs.org/#isUndefined _.isUndefined(value)
http://underscorejs.org/#has _.has(object, key)

答案 34 :(得分：4)

您可以验证以下方式并了解其中的差异。

＆＃13;
＆＃13; 
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");
＆＃13;
＆＃13;
＆＃13;

答案 35 :(得分：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' />

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

答案 36 :(得分：3)

您应该始终检查类型，因为JavaScript是一种鸭子类型的语言，因此您可能不知道数据在流程中间何时以及如何更改。所以，这是更好的解决方案：

var str = "";
if (str === "") {
    //...
}

答案 37 :(得分：3)

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

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

根据@kip2 的建议进行编辑。

答案 38 :(得分：3)

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

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

答案 39 :(得分：2)

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

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

我希望这会有所帮助。

答案 40 :(得分：2)

如果要检查字符串是否为空/空/未定义，使用如下代码：

let emptyStr;
if (!emptyStr) {
  // String is empty
}

如果字符串为空/null/undefined if condition can return false:

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

当字符串不为空或未定义时，并且您打算检查一个空字符串时，您可以使用字符串原型的长度属性，如下所示：

let emptyStr = "";
if (!emptyStr && emptyStr.length == 0) {
  console.log("String is empty");
}

另一种选择是使用比较运算符“===”检查空字符串。

它在以下示例中可视化：

let emptyStr = "";
if (emptyStr === "") {
  console.log("String is empty");
}

答案 41 :(得分：2)

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

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

答案 42 :(得分：2)

使用null-coalescing运算符修剪空格：

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

答案 43 :(得分：2)

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

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

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

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

答案 44 :(得分：0)

在下面的代码段中，我将使用不同的输入参数比较选择的18种方法

  • "" "a" " "-空字符串，带字母的字符串和带空格的字符串
  • [] {} f-数组，对象和函数
  • 0 1 NaN Infinity-数字
  • true false-布尔
  • null undefined

并非所有经过测试的方法都支持所有输入情况

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(" ")}`);
let log4 = (s,f)=> console.log(`${s}: ${f("a")}    ${f("d ")}`);



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



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

答案 45 :(得分：0)

检查以下所有情况：

  1. 空

  2. 未定义

  3. 0

  4. “”（空字符串）

  5. false

  6. NaN

答案 46 :(得分：0)

此函数对我来说效果很好，确保它既是字符串也不是空的：

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

答案 47 :(得分：0)

尝试一下：

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

答案 48 :(得分：0)

您可以简单地使用 !! 并且如果字符串具有值，则始终返回 true。还可用于检查空值或未定义值。 签出以下狙击：

let strUnd = undefined;
let strNull = null;
let strEmpty = '';
let str = 'val';

console.log(`strUnd -> ${!!strUnd}`); // false
console.log(`strNull -> ${!!strNull}`); // false
console.log(`strEmpty -> ${!!strEmpty}`); // false
console.log(`str -> ${!!str}`); // true

答案 49 :(得分：0)

到目前为止，还没有像string.empty这样的直接方法来检查字符串是否为空。但是在您的代码中，您可以使用包装器检查空字符串，例如：

// considering the variable in which your string is saved is named str.
if(str !== null || str!== undefined){
  if (str.length>0) { 

  // Your code here which you want to run if the string is not empty.

  }
}

使用此方法，您还可以确保字符串也未定义或为null。请记住，未定义，null和empty是三个不同的东西。

答案 50 :(得分：0)

对于那些为 js 字符串寻找 rails .blank? 的人：

function is_blank(str) { 
  return (!str || str.length === 0 || str.trim() == '')
}

答案 51 :(得分：0)

这是另一种带有字符串修剪选项的类型，它是防错的：

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

答案 52 :(得分：0)

我已经尝试了这里建议的几个示例。我的目标是不仅能够检查空，而且！空。这就是结果 在这些解决方案中我唯一找不到的是如何检测函数中的未定义，如果它至少没有被声明。也许这是不可能的。

function empty(data)
{
    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
============
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)

答案 53 :(得分：0)

嗯，检查这个最简单的函数是......

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

用法：

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

就是这么简单。 :)

答案 54 :(得分：-3)

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

答案 55 :(得分：-5)

<html>
<head>
<script lang="javascript">

function nullcheck()
{
var n="fdgdfg";
var e = n.length;
if(e== 0)
{

    return true;
}
else
{
    alert("sucess");
    return false;
}
}


</script>
</head>
<body>
<button type="submit" value="add" onclick="nullcheck()"></button>
</body>
</html>

答案 56 :(得分：-12)

检查它是否为空：

var str = "Hello World!";
var n = str.length;
if(n === ''){alert("THE STRING str is EMPTY");}

检查它是否为空

var str = "Hello World!";
var n = str.length;
if(n != ''){alert("THE STRING str isn't EMPTY");}
相关问题
最新问题