我看到了这个问题，但没有看到 JavaScript 特定的示例。JavaScript中是否有一个简单的string.Empty可用，或者它只是一个检查的情况""？
Saul
问问题
4299452 次
59 回答
1339
为了检查变量是否为假或者它的长度属性是否等于零（对于字符串来说，这意味着它是空的），我使用：
function isEmpty(str) {
return (!str || str.length === 0 );
}
（请注意，字符串不是唯一具有length属性的变量，例如，数组也有它们。）
为了检查变量是否为假或字符串是否仅包含空格或为空，我使用：
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 whitespace
return (this.length === 0 || !this.trim());
};
console.log("example".isEmpty());
请注意，猴子修补内置类型是有争议的，因为无论出于何种原因，它都可能破坏依赖于内置类型现有结构的代码。
于 2010-07-16T01:45:58.773 回答
486
以前的所有答案都很好，但这会更好。使用双重 NOT 运算符 ( !!)：
if (!!str) {
// Some code here
}
或使用类型转换：
if (Boolean(str)) {
// Code here
}
两者都执行相同的功能。将变量类型转换为布尔值，其中str是一个变量。
它返回
false,null,undefined,0,000,""。false它返回
true除空字符串以外的所有字符串值（包括和之类的"0"字符串" "）
于 2011-03-30T13:34:22.147 回答
125
您可以得到的最接近的东西str.Empty（前提是 str 是一个字符串）是：
if (!str.length) { ...
于 2008-09-30T19:17:32.003 回答
111
如果您需要确保字符串不仅仅是一堆空格（我假设这是用于表单验证），您需要对空格进行替换。
if(str.replace(/\s/g,"") == ""){
}
于 2008-09-30T23:08:32.510 回答
71
我用：
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
于 2010-07-09T18:52:40.450 回答
55
您可以使用lodash：_.isEmpty(value)。
它涵盖了很多情况，例如{}, '', null,undefined等。
但它总是返回JavaScript 原始数据类型的true类型，例如 return或两者都返回。Number_.isEmpty(10)_.isEmpty(Number.MAX_VALUE)true
于 2017-08-17T06:51:14.923 回答
55
表现
我在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- 布尔值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 = ""为浏览器 Chrome v78.0.0、Safari v13.0.4 和 Firefox v71.0.0 执行速度测试用例 - 您可以在此处在您的机器上运行测试
于 2019-12-31T18:48:11.937 回答
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))
);
}
但是，我不建议使用它，因为您的目标变量应该是特定类型（即字符串、数字或对象？），因此请应用与该变量相关的检查。
于 2014-02-27T20:31:28.310 回答
39
var s; // undefined
var s = ""; // ""
s.length // 0
JavaScript 中没有任何内容代表空字符串。进行检查length（如果您知道 var 将始终是字符串）或检查""
于 2008-09-30T17:42:32.543 回答
37
尝试：
if (str && str.trim().length) {
//...
}
于 2013-01-09T02:54:50.370 回答
31
我不会太担心最有效的方法。使用对您的意图最清楚的内容。对我来说这通常是strVar == "".
根据来自Constantin的评论，如果 strVar 可能最终包含一个整数 0 值，那么这确实是那些意图澄清的情况之一。
于 2008-09-30T17:20:57.323 回答
21
您也可以使用正则表达式：
if((/^\s*$/).test(str)) { }
检查为空或填充有空格的字符串。
于 2010-05-31T14:57:38.887 回答
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;
}有点过分，我知道。
于 2016-03-31T08:29:46.890 回答
20
- 检查
var a;存在 修剪掉
false spacesin 值，然后测试emptinessif ((a)&&(a.trim()!='')) { // if variable a is not empty do this }
于 2015-02-24T15:38:42.140 回答
18
我通常使用这样的东西，
if (!str.length) {
// Do something
}
于 2013-08-09T10:10:50.573 回答
17
此外，如果您将空格填充的字符串视为“空”。
您可以使用以下正则表达式对其进行测试：
!/\S/.test(string); // Returns true if blank.
于 2013-05-15T14:55:15.700 回答
15
如果一个人不仅需要检测空字符串，还需要检测空字符串，我将添加到 Goral 的答案中：
function isEmpty(s){
return !s.length;
}
function isBlank(s){
return isEmpty(s.trim());
}
于 2014-10-01T06:55:13.743 回答
13
我使用组合，最快的检查是第一个。
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);
}
于 2011-06-01T15:40:33.437 回答
13
从...开始：
return (!value || value == undefined || value == "" || value.length == 0);
查看最后一个条件，如果 value == ""，则它的长度必须为 0。因此删除它：
return (!value || value == undefined || value == "");
可是等等！在 JavaScript 中，空字符串为假。因此，丢弃值 == ""：
return (!value || value == undefined);
并且 !undefined 为真，因此不需要检查。所以我们有：
return (!value);
而且我们不需要括号：
return !value
于 2020-02-10T08:34:31.653 回答
12
我没有注意到考虑到字符串中可能存在空字符的答案。例如，如果我们有一个空字符串：
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 空字符或空白字符（即不间断空格、字节顺序标记、行/段落分隔符等）。
于 2012-07-31T14:05:04.670 回答
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
于 2018-03-12T08:48:23.637 回答
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 是三个不同的东西。
于 2019-04-11T12:16:21.823 回答
11
我在这里没有看到好的答案（至少不是适合我的答案）
所以我决定回答自己：
value === undefined || value === null || value === "";
您需要开始检查它是否未定义。否则您的方法可能会爆炸，然后您可以检查它是否等于 null 或等于空字符串。
你不能有！！或者只是if(value)因为如果你检查0它会给你一个错误的答案（0是错误的）。
话虽如此，将其包装在如下方法中：
public static isEmpty(value: any): boolean {
return value === undefined || value === null || value === "";
}
PS.：您不需要检查 typeof，因为它甚至在进入方法之前就会爆炸并抛出
于 2019-10-23T21:13:57.653 回答
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上的示例。
于 2013-05-08T17:15:40.953 回答
10
我对如果将非字符串和非空/空值传递给测试器函数会发生什么进行了一些研究。众所周知， (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 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; } }]
];
于 2013-05-14T10:18:36.587 回答
10
要检查它是否完全是一个空字符串：
if(val==="")...
要检查它是否是空字符串或无值的逻辑等效项（null、undefined、0、NaN、false、...）：
if(!val)...
于 2017-06-02T08:33:53.163 回答
10
使用 null-coalescing 运算符修剪空白：
if (!str?.trim()) {
// do something...
}
于 2020-12-04T09:55:27.050 回答
9
没有isEmpty()方法，你必须检查类型和长度：
if (typeof test === 'string' && test.length === 0){
...
需要进行类型检查以避免在testisundefined或时出现运行时错误null。
于 2016-11-04T22:28:45.243 回答
9
试试这个：
export const isEmpty = string => (!string || !string.length);
于 2019-05-10T21:33:38.653 回答
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;
于 2020-08-24T09:55:30.200 回答
8
忽略空白字符串，您可以使用它来检查 null、空和未定义：
var obj = {};
(!!obj.str) // Returns false
obj.str = "";
(!!obj.str) // Returns false
obj.str = null;
(!!obj.str) // Returns false
它很简洁，适用于未定义的属性，尽管它不是最易读的。
于 2012-07-19T02:00:00.983 回答
7
试试这个
str.value.length == 0
于 2010-07-22T15:30:53.933 回答
7
不要假设您检查的变量是字符串。不要假设如果这个 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 === '')
...
于 2013-07-15T10:55:44.933 回答
7
您可以轻松地将其添加到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
于 2017-10-07T02:33:01.343 回答
6
我通常使用类似的东西：
if (str == "") {
//Do Something
}
else {
//Do Something Else
}
于 2010-02-15T02:46:49.510 回答
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");于 2017-11-30T06:26:50.223 回答
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
我希望这会有所帮助。
于 2020-11-05T19:24:26.300 回答
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");
}于 2014-05-06T06:38:00.287 回答
5
以下正则表达式是另一种解决方案，可用于 null、空或未定义的字符串。
(/(null|undefined|^$)/).test(null)
我添加了这个解决方案，因为它可以进一步扩展以检查空值或某些值，如下所示。以下正则表达式正在检查字符串可以为空 null undefined 还是只有整数。
(/(null|undefined|^$|^\d+$)/).test()
于 2019-10-18T09:02:47.140 回答
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' />
这也是检查字段是否为空的通用方法。
于 2010-08-06T16:28:06.440 回答
4
我更喜欢使用非空白测试而不是空白
function isNotBlank(str) {
return (str && /^\s*$/.test(str));
}
于 2013-07-03T04:16:06.887 回答
4
Underscore.js JavaScript库http://underscorejs.org/提供了一个非常有用的_.isEmpty()函数来检查空字符串和其他空对象。
参考：http ://underscorejs.org/#isEmpty
isEmpty
_.isEmpty(object)
如果可枚举对象不包含任何值（没有可枚举的自身属性），则返回 true。对于字符串和类似数组的对象，_.isEmpty 检查长度属性是否为 0。
_.isEmpty([1, 2, 3]);
=> 假的
_.isEmpty({});
=> 真
其他非常有用的 Underscore.js 功能包括：
- http://underscorejs.org/#isNull
_.isNull(object) - http://underscorejs.org/#isUndefined
_.isUndefined(value)- http://underscorejs.org/#has
_.has(object, key)
于 2015-06-10T08:44:51.057 回答
3
检查您是否没有尝试传递未定义的术语也是一个好主意。
function TestMe() {
if((typeof str != 'undefined') && str) {
alert(str);
}
};
TestMe();
var str = 'hello';
TestMe();
当对象实例的字符串属性不为空时，我通常会遇到想要做某事的情况。这很好，只是该属性并不总是存在。
于 2012-12-18T22:31:17.503 回答
3
您可以使用 typeof 运算符和 length 方法来检查这一点。
const isNonEmptyString = (value) => typeof(value) == 'string' && value.length > 0
根据@kip2 的建议进行编辑。
于 2021-01-14T17:04:29.507 回答
3
只需检查变量是否存在且不为空。
//let Str = "";
if (Str && Str.length !== 0) {
console.log("String is not empty");
}
于 2021-09-13T12:31:09.303 回答
3
试试这个代码：
function isEmpty(strValue)
{
// Test whether strValue is empty
if (!strValue || strValue.trim() === "" || (strValue.trim()).length === 0) {
//do something
}
}
于 2021-10-08T07:56:46.703 回答
3
这就是falsy价值。
虚假值
第一个解决方案：
const str = "";
return str || "Hello"
第二种解决方案：
const str = "";
return (!!str) || "Hello"; // !!str is Boolean
第三种解决方案：
const str = "";
return (+str) || "Hello"; // !!str is Boolean
于 2021-10-13T18:13:16.193 回答
2
另一种方式，但我相信bdukes 的答案是最好的。
var myString = 'hello';
if(myString.charAt(0)){
alert('no empty');
}
alert('empty');
于 2013-02-10T10:20:48.167 回答
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"));于 2021-08-22T10:12:54.757 回答
0
这个函数对我来说效果很好，确保它既是字符串又不是空的：
isNonBlankString = function(s) { return ((typeof s === 'string' || s instanceof String) && s !== ''); }
于 2020-12-15T16:58:08.483 回答
0
对于那些寻找.blank?js 字符串的 rails 的人：
function is_blank(str) {
return (!str || str.length === 0 || str.trim() == '')
}
于 2021-06-12T08:58:13.597 回答
0
好吧，检查这个的最简单的功能是......
const checkEmpty = string => (string.trim() === "") || !string.trim();
用法：
checkEmpty(""); // returns true.
checkEmpty("mystr"); // returns false.
就是这么简单。:)
于 2021-07-04T06:16:58.440 回答
-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")
}
于 2014-04-08T09:37:02.127 回答
-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;
}
}于 2021-06-16T11:33:42.440 回答
-2
我已经尝试了这里建议的几个示例。我的目标是不仅能够检查空，而且能够检查！empty。这就是结果我在这些解决方案中唯一找不到的是如何检测函数中的未定义，如果它至少没有被声明。也许这是不可能的。
我将其扩展为包括数组。看看小提琴。这确实有效。
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
于 2021-06-23T15:29:15.947 回答
-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
于 2021-11-09T21:04:36.697 回答
-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>
于 2015-03-25T09:37:11.483 回答
-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");}
于 2014-07-19T18:15:50.973 回答