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

String(x) === x // true, if x is a string
                // false in every other case

常量测试=x=>控制台断言（字符串（x）==x，`不是字符串：$｛x｝`)测试（“某些字符串”）测试（123）//断言失败测试（0）//断言失败测试（/some regex/）//断言失败测试（[5]，6]）//断言失败测试（｛a:1｝）//断言失败测试（x=>x+1）//断言失败

同样的技术也适用于Number-

Number(x) === x // true, if x is a number
                // false in every other case

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

对于RegExp-

RegExp(x) === x // true, if x is a regexp
                // false in every other case

常量测试=x=>控制台断言（RegExp（x）==x，`不是正则表达式：$｛x｝`)test（“some string”）//断言失败测试（123）//断言失败测试（0）//断言失败测试（/some regex/）测试（[5]，6]）//断言失败测试（｛a:1｝）//断言失败测试（x=>x+1）//断言失败

与对象相同-

Object(x) === x // true, if x is an object
                // false in every other case

NB、正则表达式、数组和函数也被视为对象。

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

但是，检查Array有点不同-

Array.isArray(x) === x // true, if x is an array
                       // false in every other case

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

但是，此技术不适用于函数-

Function(x) === x // always false

对于@Faither-

const fmt=JSON.stringify函数测试1（）{常量a=“1”常量b=1console.log（`编号（$｛fmt（a）｝）==$｛mt（b）｝`，编号（a）==b）//true}函数测试2（）{常量a=“1”常量b=1console.log（`Number.isInteger（${fmt（a）}）`，Number.isInteger（a））//falseconsole.log（`Number.isInteger（${fmt（b）}）`，Number.isInteger（b））//true}函数测试3（）{name=1//全局名称将始终为字符串console.log（fmt（名称））//“1”console.log（`字符串（$｛fmt（名称）｝）==$｛mt（名称）}`，字符串（名称）==名称）//true}函数测试4（）{常量名称=1//本地名称console.log（fmt（名称））//1console.log（`字符串（$｛fmt（名称）｝）==$｛mt（名称）}`，字符串（名称）==名称）//false}测试1（）；test2（）；测试3（）；测试4（）

最佳方式：

var s = 'String';
var a = [1,2,3];
var o = {key: 'val'};

(s.constructor === String) && console.log('its a string');
(a.constructor === Array) && console.log('its an array');
(o.constructor === Object) && console.log('its an object');
(o.constructor === Number || s.constructor === Boolean) && console.log('this won\'t run');

其中的每一个都是由其相应的类函数构造的，如“new Object（）”等。

此外，鸭子打字：“如果它看起来像鸭子，走路像鸭子，闻起来像鸭子，那一定是一个阵列”意思是，检查它的财产。

希望这有帮助。

编辑12/05/2016

记住，你也可以使用各种方法的组合。以下是使用类型为的内联操作映射的示例：

var type = { 'number': Math.sqrt.bind(Math), ... }[ typeof datum ];

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

function is(datum) {
    var isnt = !{ null: true, undefined: true, '': true, false: false, 0: false }[ datum ];
    return !isnt;
}
console.log( is(0), is(false), is(undefined), ... );  // >> true true false

该函数将使用[custom]“类型转换”，而不是“类型-/-值映射”，来确定变量是否实际“存在”。现在，你可以在0和0之间分割那讨厌的头发了！

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

this.id = "998";  // use a number or a string-equivalent
function get(id) {
    if (!id || !id.toString) return;
    if (id.toString() === this.id.toString()) http( id || +this.id );
    // if (+id === +this.id) ...;
}

Number.prototype和String.prototype都有.toString（）方法。您只需确保与数字等效的字符串相同，然后确保将其作为数字传递给http函数。换句话说，我们甚至不在乎它的类型。

希望能给你更多的工作机会：）

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

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

lodash/Undercore.js

if(_.isString(myVar))
   //it's a string
else
   //it's something else

jQuery

if($.type(myVar) === "string")
   //it's a string
else
   //it's something else

有关详细信息，请参阅_.isString（）的lodash文档。

有关详细信息，请参阅$.type（）的jQuery文档。

由于有580+人投票给了一个错误的答案，而有800+人投票支持一个有效但猎枪式的答案，我认为应该用一种大家都能理解的更简单的形式来重复我的答案。

function isString(x) {
  return Object.prototype.toString.call(x) === "[object String]"
}

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

Object.prototype.toString.call(myVar) === "[object String]"

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

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

然而，这个答案也绝对正确，实际上是最好的答案（除了使用lodash/下划线的建议）。免责声明：我为lodash 4代码库做了贡献。

我最初的答案（很明显，很多人都是这么想的）如下：

我从underscore.js代码转换了这个：

['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'].forEach( 
    function(name) { 
        window['is' + name] = function(obj) {
              return toString.call(obj) == '[object ' + name + ']';
    }; 
});

这将定义isString、isNumber等。

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

module.exports = [
  'Arguments',
  'Function', 
  'String', 
  'Number', 
  'Date', 
  'RegExp'
].reduce( (obj, name) => {
  obj[ 'is' + name ] = x => toString.call(x) == '[object ' + name + ']';
  return obj;
}, {});

[编辑]：Object.protype.toString.call（x）也可以在函数和异步函数之间进行描述：

const fn1=（）=>new Promise（（resolve，reject）=>setTimeout（（）=>resolve（｛｝），1000））常量fn2=async（）=>（｛｝）console.log（'fn1'，Object.pr原型.toString.call（fn1））console.log（'fn2'，Object.pr原型.toString.call（fn2））

我有一个愚蠢的技巧。但直截了当。

if(maybeAString.toUpperCase)
  weHaveAString(maybeAString)

是的，这远非完美。但这很简单。

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

isNaN("A") = true;
parseInt("A") = NaN;
isNaN(NaN) = true;

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

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