检查变量是否是JavaScript中的字符串

Question

如何确定变量是字符串还是JavaScript中的其他变量？

Answer 1

这对我来说很有效：

if（typeofmyVar==='string'||myVar instanceofString）//这是一根绳子其他的//这是另一回事

//测试此方法：让isString=value=>typeofvalue==='string'||valueinstanceofString；let falseCase=[[“null”，null]，[“未定义”，未定义]，[“对象”，{a:1，b:2}]，[“数组”，[1，2，3]]，['数字'，123]，[“零”，0]，[“RegExp”，新RegExp（“hello”）]，[“number with valueOf returning string”，Object.assign（10，{valueOf:（）=>“abc”}）]，['伪装成字符串的对象'，{constructor:string}]];让trueCase=[['空文本字符串'，'']，['unicode string literal'，string.fromCharCode（10000）]，['空的装箱字符串'，新字符串（''）]，[“unicode装箱字符串”，新字符串（string.fromCharCode（10000））]，['带覆盖“constructor”的字符串'，Object.assign（'hi'，{constructor:Array}）]，['string with overrided“toString”'，Object.assign（'hi'，{toString:123}）]，['带覆盖“valueOf”'的字符串，Object.assign（'hi'，{valueOf:123}）]，['带覆盖“constructor”的字符串'，Object.assign（'hi'，{constructor:RegExp}）]，[“代理字符串”，new Proxy（new string（'hello'），{}）]，];console.log（'负面测试：'）；for（falseCases的let[name，val]）{console.log（`Test${name}:\n预期：false\n获得：${isString（val）}`）；}console.log（'\nPOSITIVE TESTS:'）；for（let[name，val]of trueCases）{console.log（`Test${name}:\n期望：true\n得到：${isString（val）}`）；}

Answer 2

你可以使用类型操作员：

var booleanValue=true；var数值=354；var stringValue=“这是一个字符串”；var stringObject=new String（“这是一个字符串对象”）；console.log（typeofbooleanValue）//显示“boolean”console.log（typeofnumericalValue）//显示“数字”console.log（typeofstringValue）//显示“string”console.log（字符串对象类型）//显示“对象”

示例来自这个网页（但示例稍作修改）。

对于使用创建的字符串，这将无法按预期工作新建字符串（），但很少使用，建议不要使用^[1][2]。如果您愿意，请参阅其他答案以了解如何处理这些问题。

//测试此方法：让isString=value=>typeof value===“字符串”；let falseCase=[[“null”，null]，[“未定义”，未定义]，[“对象”，{a:1，b:2}]，[“数组”，[1，2，3]]，[“数字”，123]，[“零”，0]，['RegExp'，新RegExp（'hello'）]，[“number with valueOf returning string”，Object.assign（10，{valueOf:（）=>“abc”}）]，['伪装成字符串的对象'，{constructor:string}]];让trueCase=[['空文本字符串'，'']，['unicode string literal'，string.fromCharCode（10000）]，[“空装箱字符串”，新字符串（“”）]，[“unicode装箱字符串”，新字符串（string.fromCharCode（10000））]，['带覆盖“constructor”的字符串'，Object.assign（'hi'，{constructor:Array}）]，['string with overrided“toString”'，Object.assign（'hi'，{toString:123}）]，['带覆盖“valueOf”'的字符串，Object.assign（'hi'，{valueOf:123}）]，['带覆盖“constructor”的字符串'，Object.assign（'hi'，{constructor:RegExp}）]，[“代理字符串”，new Proxy（new string（'hello'），{}）]，];console.log（'负面测试：'）；for（falseCases的let[name，val]）{console.log（`Test${name}:\n预期：false\n获得：${isString（val）}`）；}console.log（'\nPOSITIVE TESTS:'）；for（let[name，val]of trueCases）{console.log（`Test${name}:\n期望：true\n得到：${isString（val）}`）；}

---

1. 谷歌JavaScript风格指南说永远不要使用原始对象包装器.
2. 道格拉斯·克罗克福德建议弃用基本对象包装器.

Answer 3

函数isString（x）{return Object.protype.toString.call（x）===“[Object String]”}

或者，内联（我有一个UltiSnip设置）：

Object.prototype.toString.call（myVar）===“[Object String]”

仅供参考，巴勃罗·圣克鲁斯的回答是错误的，因为新字符串的类型（“字符串”）是对象

DRAX的答案准确且实用，应该是正确的答案（因为巴勃罗·圣克鲁斯（Pablo Santa Cruz）绝对是错误的，我不会反对公众投票。）

然而，这个答案也绝对正确，实际上是最好的答案（也许除了建议使用洛达什/强调).免责声明：我为lodash 4代码库做了贡献。

我最初的回答（显然是从很多人的头上飞过去的）如下：

我从underscore.js中转码了这个：

['Arguments'，'Function'，'String'，'Number'，'Date'，'RegExp'].forEach（函数（名称）{窗口['is'+名称]=函数（obj）{return toString.call（obj）=='[对象'+name+']'；}; });

这将定义isString、isNumber等。

---

在Node.js中，这可以作为一个模块实现：

模块导出=[“参数”，“函数”，“字符串”，“数字”，'日期'，“RegExp”].reduce（（obj，name）=>{obj['是'+name]=x=>toString.call（x）=='[对象'+name+']'；返回对象；}, {});

[编辑]：Object.prototype.toString.call（x）用于在函数和异步函数之间进行划分：

const fn1=（）=>new Promise（（resolve，reject）=>setTimeout（（）=>resolve（{}），1000））const fn2=async（）=>（｛｝）console.log（'fn1'，Object.prototype.toString.call（fn1））console.log（'fn2'，Object.prototype.toString.call（fn2））

//测试此方法：函数isString（x）{return Object.prototype.toString.call（x）===“[Object String]”}let falseCase=[[“null”，null]，[“未定义”，未定义]，[“对象”，{a:1，b:2}]，['数组'，[1，2，3]，['数字'，123]，[“零”，0]，['RegExp'，新RegExp（'hello'）]，[“number with valueOf returning string”，Object.assign（10，{valueOf:（）=>“abc”}）]，['伪装成字符串的对象'，{constructor:string}]];让trueCase=[['空文本字符串'，'']，['unicode string literal'，string.fromCharCode（10000）]，[“空装箱字符串”，新字符串（“”）]，[“unicode装箱字符串”，新字符串（string.fromCharCode（10000））]，['带覆盖“constructor”的字符串'，Object.assign（'hi'，{constructor:Array}）]，['string with overrided“toString”'，Object.assign（'hi'，{toString:123}）]，['带覆盖“valueOf”'的字符串，Object.assign（'hi'，{valueOf:123}）]，['带覆盖“constructor”的字符串'，Object.assign（'hi'，{constructor:RegExp}）]，[“代理字符串”，new Proxy（new string（'hello'），{}）]，];console.log（'负面测试：'）；for（falseCases的let[name，val]）{console.log（`Test${name}:\n预期：false\n获得：${isString（val）}`）；}console.log（'\nPOSITIVE TESTS:'）；for（let[name，val]of trueCases）{console.log（`Test${name}:\n期望：true\n得到：${isString（val）}`）；}

Answer 4

我建议使用中的内置函数jQuery（jQuery）或lodash/底芯。它们更易于使用和阅读。

任何一个函数都将处理上述DRAX的情况。。。也就是说，他们二者都检查（A）变量是字符串文字还是（B）它是string对象的实例。在这两种情况下，这些函数都可以正确地将值标识为字符串。

lodash/Underscore.js

if（_.isString（myVar））//这是一根绳子其他的//这是另一回事

jQuery（jQuery）

if（$.type（myVar）===“字符串”）//这是一根绳子其他的//是别的东西

请参见_.isString（）的lodash文档了解更多详细信息。

请参见$.type（）的jQuery文档了解更多详细信息。

Answer 5

编辑：当前的方法是typeof value===“字符串”例如：

const str='hello'；if（typeofstr==='string'）{…}

自节点v4以来，以下内容已被弃用。

如果您使用node.js环境，只需在utils中使用内置函数isString。

const-util=要求（'util'）；if（util.isString（myVar））｛｝

Answer 6

函数isString（obj）{return（Object.prototype.toString.call（obj）===“[Object String]”）；}

我在这里看到了：

http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/

Answer 7

最佳方式：

var s=“字符串”；变量a=[1,2,3]；var o=｛key:'val'｝；（s.constructor===String）&&console.log（'它是一个字符串'）；（a.constructor===数组）&&console.log（'它是一个数组'）；（o.constructor===对象）&&console.log（'它是一个对象'）；（o.constructor===数字||s.constructor===布尔值）&&console.log（'这不会运行'）；

这些都是由其适当的类函数构造的，如“new Object（）”等。

此外，鸭子打字：“如果它看起来像只鸭子，走路像鸭子，闻起来像鸭子-它一定是一个数组”也就是说，检查它的属性。

希望这能有所帮助。

编辑；12/05/2016

记住，你也可以随时使用各种方法的组合。下面是使用内联映射的操作类型:

var type={“number”：数学.sqrt.bind（数学），…}[数据类型]；

下面是一个更“真实”的使用内联映射的示例：

功能是（基准）{var isnt=！{null:true，undefined:true，''：true，false:false，0:false}[datum]；返回！不是；}console.log（是（0），是（false），是[未定义]，…）；//>>真-真-假

这个函数将使用[custom]“type-casting”（而不是“type-/-value-mapping”）来判断变量是否真的“存在”。现在你可以把那讨厌的头发分开了无效的&0!

多次你甚至不在乎它的类型。另一种避免键入的方法是组合Duck-Type集合：

this.id=“998”；//使用数字或等效字符串函数get（id）{if（！id||！id.toString）return；if（id.toString（）===this.id.toString（））http（id||+this.id）；//如果（+id===+this.id）。。。；}

两者都有编号.原型 和 字符串.原型有一个.toString（）方法。您只需确保数字的字符串等价物相同，然后确保将其传递到http协议作为编号换句话说，我们甚至没有照顾它的类型是什么。

希望能为您提供更多合作机会：）

Answer 8

我真的不明白为什么人们不直接使用类型在这种情况下：

if（类型str===“字符串”）{返回42；}

是的，它会针对对象封装字符串失败（例如。新字符串（'foo'）)但这些都被广泛认为是一种糟糕的做法，大多数现代开发工具可能会阻碍其使用。（如果你看到一个，就把它修好！）

这个对象.原型.to字符串技巧是所有前端开发人员在职业生涯中的某一天都会犯下的错误，但不要让它通过巧妙的修饰来愚弄你：只要有什么东西与Object原型相匹配，它就会崩溃：

const isString=thing=>Object.prototype.toString.call（thing）===“[Object String]”；console.log（isString（'foo'））；Object.prototype.toString=（）=>42；console.log（isString（'foo'））；

Answer 9

性能

今天2020.09.17，我在Chrome v85、Safari v13.1.2和Firefox v80上对MacO HighSierra 10.13.6进行了测试，以获得选定的解决方案。

结果

对于所有浏览器（以及两个测试用例）

• 解决typeof实例（A、I）和x===x+''（H） 速度快/最快
• 解决方案_.is字符串（lodash库）为中等/快速
• 解决方案B和K最慢

更新：2020.11.28更新结果x=123铬列-用于解决方案我之前可能有一个错误值（=69M太低）-我使用Chrome 86.0来重复测试。

细节

我为解决方案执行了2个测试用例A类 B类 C类 D类 E类 F类 克 H（H） 我 J型 K（K） L（左）

• 当变量是字符串时，您可以运行它酒店雇员和饭馆雇员
• 当变量不是字符串时-可以运行它酒店雇员和饭馆雇员

以下片段介绍了解决方案之间的差异

// https://stackoverflow.com/a/9436948/860099函数A（x）{return（typeofx=='string'）||（xinstanceofString）}// https://stackoverflow.com/a/17772086/860099函数B（x）{return Object.protype.toString.call（x）===“[Object String]”}// https://stackoverflow.com/a/20958909/860099函数C（x）{return _.isString（x）；}// https://stackoverflow.com/a/20958909/860099函数D（x）{return$.type（x）===“string”；}// https://stackoverflow.com/a/16215800/860099函数E（x）{返回x？。构造函数===字符串；}// https://stackoverflow.com/a/42493631/860099函数F（x）{返回x？。charAt！=字符无效的}// https://stackoverflow.com/a/57443488/860099函数G（x）{返回字符串（x）===x}// https://stackoverflow.com/a/19057360/860099函数H（x）{返回x===x+''}// https://stackoverflow.com/a/4059166/860099函数I（x）{返回类型x==“字符串”}// https://stackoverflow.com/a/28722301/860099函数J（x）{返回x===x？。toString（）}// https://stackoverflow.com/a/58892465/860099函数K（x）{return x&&typeof x.valueOf（）===“字符串”}// https://stackoverflow.com/a/9436948/860099函数L（x）{返回字符串的x实例}// ------------------//演示文稿// ------------------console.log（“不同输入的解决方案结果”）；console.log（“'abc'Str'”“'1'”“0'1 0{}[]true false null undef”）；let tests=['abc'，new String（“abc”），''，''，'1'，'0'，1,0，{}，[]，true，false，null，undefined]；[A，B，C，D，E，F，G，H，I，J，K，L].映射（F=>{控制台.log(`$｛f.name｝`+tests.map（v=>（1*！！f（v）））.join``)})

<script src=“https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js“></script><script src=“https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.20/lodash.min.js“integrity=”sha512-90vH1Z83AJY9DmlWa8WkjkV79yfS2n2Oxhsi2dZbIv0nC4E6m5AbH8Nh156kkM7JePmqD6tcZsfad1ueoaovwww==“crossorigin=”anonymous“></script>这艘船只提供性能测试中使用的功能，它本身不执行测试！

下面是铬的示例结果

Answer 10

这是一个很好的例子，说明为什么性能很重要：

如果操作不正确，对字符串进行测试这样简单的操作可能会代价高昂。

例如，如果我想编写一个函数来测试某个东西是否是字符串，我可以使用以下两种方法之一：

1)const isString=str=>（Object.prototype.toString.call（str）===“[Object String]”）；

2)const isString=str=>（（typeof str==“string”）| |（str instanceof string））；

这两项都非常简单，那么什么可能会影响性能呢？一般来说，函数调用可能很昂贵，尤其是当您不知道内部发生了什么时。在第一个示例中，有一个对Object的toString方法的函数调用。在第二个示例中，没有函数调用，因为typeof和instanceof是运算符。运算符比函数调用快得多。

测试性能时，示例1比示例2慢79%！

请参阅测试：https://jsperf.com/isstringtype

Answer 11

我喜欢使用这个简单的解决方案：

var myString=“test”；if（myString.constructor===字符串）{//这是一根绳子}

Answer 12

我发现这个简单的技巧对类型检查很有用字符串-

如果x是字符串，则字符串（x）===x//true//其他情况下均为假

常数测试=x=>控制台资产（字符串（x）===x，`不是字符串：${x}`)测试（“一些字符串”）测试（123）//断言失败测试（0）//断言失败测试（/some regex/）//断言失败测试（[5,6]）//断言失败测试（{a:1}）//断言失败测试（x=>x+1）//断言失败

同样的技术适用于编号也是-

如果x是数字，则数字（x）===x//为真//其他情况下均为假

常量测试=x=>控制台资产（数量（x）===x，`不是数字：${x}`)test（“some string”）//断言失败测试（123）测试（0）测试（/some regex/）//断言失败测试（[5,6]）//断言失败测试（{a:1}）//断言失败测试（x=>x+1）//断言失败

对于注册Exp-

如果x是RegExp，则RegExp（x）===x//为true//其他情况下均为假

常数测试=x=>控制台资产（RegExp（x）===x，`不是regexp:${x}`)test（“some string”）//断言失败测试（123）//断言失败测试（0）//断言失败测试（/some regex/）测试（[5,6]）//断言失败测试（{a:1}）//断言失败测试（x=>x+1）//断言失败

与相同对象-

如果x是对象，则对象（x）===x//为true//其他情况下均为假

NB、regexp、数组和函数也被视为对象。

常数测试=x=>控制台资产（对象（x）===x，`不是对象：${x}`)test（“some string”）//断言失败测试（123）//断言失败测试（0）//断言失败测试（/some regex/）测试（[5,6]）测试（{a:1}）测试（x=>x+1）

但是，检查阵列有点不同-

Array.isArray（x）===x//true，如果x是数组//其他情况下均为假

常数测试=x=>控制台断言（数组.isArray（x），`不是数组：${x}`)test（“some string”）//断言失败测试（123）//断言失败测试（0）//断言失败测试（/some regex/）//断言失败测试（[5，6]）测试（{a:1}）//断言失败测试（x=>x+1）//断言失败

这项技术确实不为…工作功能然而-

函数（x）===x//始终为false

---

对于@Faither-

const fmt=JSON.stringify功能测试1（）{常数a=“1”常数b=1console.log（`数字（${fmt（a）}）===${fmt（b）}`，数字（a）===b）//true}函数test2（）{常数a=“1”常数b=1console.log（`Number.isInteger（${fmt（a）}）`，Number.is Intege（a））//falseconsole.log（`Number.isInteger（${fmt（b）}）`，Number.is Integer}功能测试3（）{name=1//全局名称始终是字符串控制台.log（fmt（名称））//“1”console.log（`String（${fmt（name）}）===${fmt（name）{`，String（name）===name）//true}功能测试4（）{const名称=1//本地名称控制台.log（fmt（名称））//1console.log（`String（$｛fmt（name）｝）==$｛fmt（name）｝`，String（name）==name）//false}测试1（）；测试2（）；测试3（）；测试4（）

Answer 13

if（s&&typeofs.valueOf（）===“字符串”）{//s是字符串}

适用于两种字符串文字让s=‘废话’对于对象字符串let s=新字符串（'blah'）

Answer 14

取自洛达什：

函数isString（val）{返回类型val==='string'||（（！！val&&typeof val=='object'）&&object.prototype.toString.call（val）==='[object string]'）；}console.log（isString（'hello world！'））；//真实的console.log（isString（新字符串（'hello world'））；//真实的

Answer 15

您可以使用此函数来确定任何内容的类型：

var类型=函数（obj）{return Object.prototype.toString.apply（obj）.replace（/\[对象（.+）\]/i，'$1'）.toLowerCase（）；};

要检查变量是否为字符串：

type（'my string'）==='string'//truetype（new String（'my String'））==='String'//truetype（`my string`）==='string'//truetype（12345）===“字符串”//falsetype（{}）===“字符串”//false

https://codepen.io/patodiblasi/pen/NQXPwY？编辑器=0012

要检查其他类型：

type（null）//空类型（未定义）//未定义类型（[]）//数组类型（{}）//对象type（function（）{}）//函数类型（123）//编号type（新编号（123））//编号类型（/some_regex/）//regexptype（Symbol（“foo”））//符号

Answer 16

一种简单快速的测试方法是使用构造函数名称属性。

设x=“abc”；console.log（x.constructor.name===“String”）；//真实的让y=新字符串（'abc'）；console.log（y.constructor.name===“String”）；//真实的

性能

Answer 17

isString（）使用可选链接和最新标准检查传递的参数是否为字符串：

const isString=（值）=>{返回值？。constructor===字符串；}

Answer 18

我还发现这个也很好，它比其他例子短得多。

if（myVar===myVar+“”）{//它的字符串}其他{//是别的东西}

通过在空引号上串联，它将值转换为字符串。如果我的变量已经是字符串，则if语句成功。

Answer 19

var a=新字符串（''）var b=“”var c=[]函数isString（x）{返回x！==空&&x！==未定义&&x.constructor===字符串}console.log（isString（a））console.log（isString（b））console.log（isString（c））

Answer 20

以下方法将检查是否有任何变量是字符串(包括不存在的变量).

const is字符串=值=>{尝试{return typeof value（）===“字符串”；}捕获（错误）{返回false；}};让示例=“你好，世界！”；console.log（is_string（（）=>示例））；//真实的console.log（is_string（（）=>variable_doesnt_exist））；//假

Answer 21

Typechecker助手：

函数isFromType（变量，类型）{if（typeof type=='string'）res=（typeof variable==type.toLowerCase（））else res=（variable.constructor==类型）返回res}

用法：

isFromType（'cs'，'string'）//trueisFromType（'cs'，String）//真isFromType（['cs']，数组）//真isFromType（['cs']，'object'）//false

此外，如果您希望它是递归的（如作为对象的数组），可以使用运算符.

(['cs']对象实例//true)

Answer 22

这对我来说足够好了。

警告：这不是一个完美的解决方案。请参阅我帖子的底部。

Object.prototype.isString=函数（）{return false；}；String.prototype.isString=函数（）{return true；}；var isString=函数（a）{return（a！==null）&&（a！=未定义）&&a.isString（）；};

你可以这样使用。

//返回falseisString（空）；isString（void 0）；isString（-123）；isString（0）；isString（true）；isString（false）；isString（[]）；isString（{}）；isString（函数（）{}）；isString（0/0）；//返回trueisString（“”）；isString（新字符串（“ABC”））；

警告：在以下情况下，此操作不正确：

//这不是字符串var对象={//但返回真实的lolisString:function（）{return true；}}isString（obj）//应为false，但应为true

Answer 23

一个简单的解决方案是：

var x=“你好”如果（x===x.toString（））{//这是一根绳子}其他{//不是这样的}

Answer 24

我将采用另一种方法来处理其余的问题，它试图判断一个变量是一个特定的类型，还是一个特定类型集的成员。
JS建立在鸭子造型上；如果某物像绳子一样嘎嘎作响，我们可以也应该像绳子一样使用它。

是7一根绳子？那为什么/\d/.测试（7）工作？
是{toString:（）=>（“你好”）}一根绳子？那为什么（{toString:（）=>（'hello there'）}）+'\ngeneral kenobi！'工作？
这些不是关于应该上面的工作，重点是他们做到了。

所以我做了一个duckyString（）功能
下面我测试了许多其他答案无法满足的情况。对于每个代码：

• 设置类字符串变量
• 对它和实际字符串运行相同的字符串操作以比较输出（证明它们可以像字符串一样处理）
• 将类字符串转换为实际字符串以显示给您duckyString（）规范需要实数字符串的代码的输入

text=“你好”；out（text.replace（/e/g，'e'）+''+'hello there'.replace'（/e/g'，'e''））；out（'是字符串？'+duckyString（text）+'\t“'+ducky字符串（text，true）+'”\n“）；text=新字符串（‘h my’）；out（text.toUpperCase（）+''+'oh my'.toUperCase（（）））；out（'是字符串？'+duckyString（text）+'\t“'+ducky字符串（text，true）+'”\n“）；文本=368；out（（text+'是一个大数字'）+“+（'368'+'是个大数字’））；out（'是字符串？'+duckyString（text）+'\t“'+ducky字符串（text，true）+'”\n“）；text=['\uD83D'，'\uDE07']；out（文本[1]。charCodeAt（0）+“+”😇'[1] .charCodeAt（0））；out（'是字符串？'+duckyString（text）+'\t“'+ducky字符串（text，true）+'”\n“）；函数文本（）{this.math=7；}；Text.protype={toString:function（）{return this.math+3+''；}}text=新文本（）；out（String.prototype.match.call（text，“0”）+“”+text.toString（）.match（“0””）；out（'是字符串？'+duckyString（text）+'\t“'+ducky字符串（text，true）+'”\n“）；

这与!!x个与…相反x===真并测试是否有数组-喜欢而不需要实际的数组。
jQuery对象；它们是数组吗？没有。它们足够好吗？是的，你可以检查一下阵列原型功能很好。
正是这种灵活性赋予了JS强大的功能和测试能力对于字符串特别降低了代码的互操作性。

上述输出为：

hEllo thErE hEllo thErE是字符串吗？真的“你好”噢我的噢我的是字符串吗？真的“哦，我的”368是一个大数字368是个大数字是字符串吗？真“368”56839 56839是字符串吗？真的”😇"0 0是字符串吗？真“10”

所以，这一切都是关于为什么？你想知道某物是不是字符串。
如果你和我一样，从谷歌来到这里，想看看是否有什么东西串状的，这是一个答案。
它甚至不昂贵，除非您使用的是真正长的或深度嵌套的字符数组。
这是因为它全部是if语句，没有像这样的函数调用.toString（）.
_{除非您试图查看一个包含仅包含toString（）的或多字节字符，在这种情况下，除了生成字符串外，没有其他方法可以进行检查，并分别计算字节组成的字符数}

函数duckyString（字符串，正常，不可接受）{var类型=空；if（！不可接受）不可接受={}；if（字符串&&！unacceptable.chars&&unacceptanable.to==null）不可接受.to=字符串.toString==数组原型.toString；if（字符串==空）;//测试“字符串”是否只是字符串否则，如果(!不可接受.is&&（字符串类型=='string'||string字符串实例）)type=“is”；//测试“string+”或“/./”。test（string）`有效否则，如果(!不可接受.to&&string.toString&&typeof string.toString==“函数”&&string.toString！=对象.原型.to字符串)type=“to”；//测试`[…string]`是否有效否则，如果(!不可接受的.chars&&（字符串长度>0 | |字符串长度==0）) {type='chars'；//对于每个字符for（var index=0；键入&index<string.length；++索引）{var char=字符串[索引]；//有效地获得其长度var长度=（（duckyString（char，false，{to:true}））？烧焦：duckyString（char，true）||{}).长度；如果（长度==1）继续；//unicode代理pair支持char=duckyString（char，true）；length=String.prototype[Symbol&&Symbol.iterator]；if（！（length=length&&length.call（char））||length.next（）.done||！length.next（）.done）type=null；}}//如果不想自动转换为实际字符串，则返回true或falseif（！（类型&&normalise））//如果他们想知道为什么它是真的，则使用<type>/null返回true或falsy返回（标准化==空）？类型！=null：类型；//执行转换开关（类型）{案例“is”：返回字符串；大小写“to”：return string.toString（）；大小写“chars”：return Array.from（string）.join（''）；}}

包括以下选项

• 询问哪个方法认为它是string-y
• 排除字符串检测方法（例如，如果您不喜欢.toString（）)

这里有更多的测试，因为我是一个完美主义者：

out（“边缘测试”）功能测试（文本、选项）{var result=duckyString（文本，false，选项）；text=duckyString（text，true，options）；out（结果+“+（结果）？”“'+text+'”：文本）；}测试（“”）；测试（空）；测试（未定义）；测试（0）；测试（｛长度：0｝）；测试（{'0'：'！'，长度：'1'}）；测试（{}）；测试（窗口）；测试（假）；测试（[“hi”]）；测试（['\uD83D\uDE07']）；测试（[['1']，2，新字符串（3）]）；测试（[['1']，2，新字符串（3）]，{chars:true}）；

• 所有阴性病例似乎都得到了解释
• 这应该在浏览器>=IE8上运行
• 支持字符串迭代器的浏览器上支持多字节的字符数组

输出：

边缘卡测试是“”null nullnull null至“0”字符“”字符“！”null null字符“”到“假”null null字符“😇"字符“123”至“1,2,3”

Answer 25

从实施洛达什图书馆4.0.0版

//获取标签.jsconst toString=Object.prototype.toString；/***获取“value”的“toStringTag”。**@私人*@param{*}value要查询的值。*@returns{string}返回`toStringTag`。*/函数getTag（值）{if（值==空）{返回值===未定义? “[对象未定义]”：“[object Null]”；}return toString.call（value）；}

//isString.js格式从“./getTag.js”导入getTag；/***检查“value”是否分类为“String”原语或对象。**@自0.1.0起*@类别Lang*@param{*}value要检查的值。*@returns{boolean}如果`value`是字符串，则返回`true`，否则返回`false`。*@示例**isString（'abc'）*//=>真**isString（1）*//=>假*/函数isString（value）{常量类型=值的类型；返回(type===“string”||（type==“object”&&值！=无效&&!Array.isArray（值）&&getTag（value）==“[object String]”）);}导出默认值为String；

Answer 26

只是为了扩展@DRAX回答，我会这样做：

函数isWhitespaceEmptyString（str）{//返回：//如果“str”是空字符串、null、未定义或仅由空白组成，则=“true”返回str！（/\S/.test（str））：（str===“”||str===null||str===未定义）；}

它还将说明无效的s和未定义类型，它将处理非字符串类型，例如0.

Answer 27

我有一个愚蠢的技巧。但很简单。

if（可能是A字符串到UpperCase）weHaveAString（可能是AString）

是的，这远非完美。但是它是简单明了。

Answer 28

我需要检查变量是否是字符串，并想“快速而脏”地完成它。这是我的方法。因为只有string具有replaceAll方法，所以这是足够的效率。

const isString=（input）=>输入类型？。replaceAll===“函数”//使用示例console.log（isString（true））//对他们俩来说，这都是真的console.log（isString（新字符串（'test'）））console.log（isString（“测试”））

Answer 29

只有字符串而没有任何数字的代码

isNaN（“A”）=真；parseInt（“A”）=NaN；isNaN（NaN）=真；

然后我们可以使用isNaN（parseInt（））来仅包含字符串

让ignoreNumbers=“ad123a4m”；让ign=ignoreNumbers.split（“”）.map（（ele）=>isNaN（parseInt（ele？ele:“”）.连接（“”）；console.log（ign）；

Answer 30

此函数是检查任何类型的安全方法：

让isType=（值，类型）=>{if（type==null||value==null）返回值===type；return Object.getPrototypeOf（value？？{}）.constructor===type；}//以下所有工作均符合预期：isType（'abc'，String）；isType（123，数字）；isType（/abc/，RegExp）；isType（null，null）；isType（未定义，未定义）；

由此我们可以得出：

让isString=value=>isType（value，String）；

//测试此方法：让isType=（值，类型）=>{if（type==null||value==null）返回值===type；return Object.getPrototypeOf（value？？{}）.constructor===type；}让isString=value=>isType（value，String）；let falseCase=[[“null”，null]，[“未定义”，未定义]，[“对象”，{a:1，b:2}]，[“数组”，[1，2，3]]，['数字'，123]，[“零”，0]，['RegExp'，新RegExp（'hello'）]，[“number with valueOf returning string”，Object.assign（10，{valueOf:（）=>“abc”}）]，['伪装成字符串的对象'，{constructor:string}]];让trueCase=[['空文本字符串'，'']，[“unicode string literal”，string.fromCharCode（10000）]，[“空装箱字符串”，新字符串（“”）]，[“unicode装箱字符串”，新字符串（string.fromCharCode（10000））]，['带覆盖“constructor”的字符串'，Object.assign（'hi'，{constructor:Array}）]，['string with overrided“toString”'，Object.assign（'hi'，{toString:123}）]，['带覆盖“valueOf”'的字符串，Object.assign（'hi'，{valueOf:123}）]，〔'带覆盖的“构造函数”的字符串'，Object.assign（'hi'，｛constructor:RegExp｝）〕，[“代理字符串”，new Proxy（new string（'hello'），{}）]，];console.log（'负面测试：'）；for（falseCases的let[name，val]）{console.log（`Test${name}:\n预期：false\n获得：${isString（val）}`）；}console.log（'\nPOSITIVE TESTS:'）；for（let[name，val]of trueCases）{console.log（`Test$｛name｝：\n预期：true \n得到：$｛isString（val）｝`）；}