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

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

您可以使用typeof运算符：

var booleanValue = true; 
var numericalValue = 354;
var stringValue = "This is a String";
var stringObject = new String( "This is a String Object" );
alert(typeof booleanValue) // displays "boolean"
alert(typeof numericalValue) // displays "number"
alert(typeof stringValue) // displays "string"
alert(typeof stringObject) // displays "object"

此网页中的示例。（尽管示例已稍作修改）。

在使用创建的字符串的情况下，这将无法正常工作new String()，但是很少使用这种方法，因此建议针对^{[1] [2]使用}。如果您愿意，请参阅其他答案以了解如何处理这些问题。

1. Google JavaScript样式指南说永远不要使用原始对象包装器。
2. 道格拉斯·克罗克福德（Douglas Crockford）建议不推荐使用原始对象包装器。

这对我有效：

if (typeof myVar === 'string' || myVar instanceof String)
// it's a string
else
// it's something else

由于580多人投票支持一个错误的答案，而800多人投票支持一个可行的but弹枪式的答案，我认为值得以一种所有人都可以理解的简单方式重做我的答案。

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

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

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

仅供参考，巴勃罗圣克鲁斯的答案是错误的，因为typeof new String("string")是object

DRAX的答案是准确且实用的，应该是正确的答案（因为Pablo Santa Cruz绝对是不正确的，我不会反对全民投票。）

但是，这个答案也绝对是正确的，并且实际上是最好的答案（也许除了建议使用lodash / underscore之外）。免责声明：我为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;
}, {});

[edit]：也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))

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

这两个函数都将处理DRAX提到的情况...也就是说，它们都检查（A）变量是字符串文字还是（B）它是String对象的实例。无论哪种情况，这些函数都可以正确地将值标识为字符串。

lodash / Underscore.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

看到 更多详细信息， lodash的_.isString（）文档。

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

function isString (obj) {
  return (Object.prototype.toString.call(obj) === '[object String]');
}

我在这里看到了：

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

最好的办法：

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（）”等。

另外，Duck-Typing：“如果它看起来像鸭子，走路像鸭子，闻起来像鸭子-它必须是数组”，含义是，检查其属性。

希望这可以帮助。

编辑; 2016/12/05

请记住，您也可以始终使用方法的组合。这是在typeof中使用动作的内联映射的示例：

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]“类型转换”（而不是“类型/值映射”）来确定变量是否确实“存在”。现在，您可以在null＆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() method。您只需确保与数字等效的字符串相同，然后确保将其http作为传递给函数Number。换句话说，我们根本不在乎它的类型。

希望能给您更多的工作:)

我无法坦白地说为什么typeof在这种情况下不能简单地使用它：

if (typeof str === 'string') {
  return 42;
}

是的，它将无法克服对象包装的字符串（例如new String('foo')），但是这些被广泛认为是不好的做法，并且大多数现代开发工具都可能会阻止它们的使用。（如果看到一个，请修复它！）

该Object.prototype.toString诀窍是什么，所有的前端开发人员已经被判有罪在自己的职业生涯有一天会做，但不要让它通过其巧妙抛光欺骗你：这会尽快打破的东西猴子补丁对象的原型：

const isString = thing => Object.prototype.toString.call(thing) === '[object String]';

console.log(isString('foo'));

Object.prototype.toString = () => 42;

console.log(isString('foo'));

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

var myString = "test";
if(myString.constructor === String)
{
     //It's a string
}

这是表现为何如此重要的一个很好的例子：

如果测试不正确，那么像测试字符串这样简单的事情可能会很昂贵。

例如，如果我想编写一个函数来测试某物是否是字符串，则可以通过以下两种方式之一来进行操作：

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

if (s && typeof s.valueOf() === "string") {
  // s is a string
}

适用于字符串文字let s = 'blah'和对象字符串let s = new String('blah')

取自lodash：

function isString(val) {
   return typeof val === 'string' || ((!!val && typeof val === 'object') && Object.prototype.toString.call(val) === '[object String]');
}

console.log(isString('hello world!')); // true
console.log(isString(new String('hello world'))); // true

我认为@customcommander解决方案可以满足您90％的情况：

typeof str === 'string'

应该为您服务正确（因为通常new String('something')在您的代码中没有理由）。

如果您有兴趣处理 String对象（例如，您希望第三者提供一些变量），则使用lodash作为@ ClearCloud8建议似乎是一个清晰，简单且优雅的解决方案。

但是，由于其大小，我建议谨慎使用lodash之类的库。而不是做

import _ from 'lodash'
...
_.isString(myVar)

这带来了整个巨大的lodash对象，我建议这样的事情：

import { isString as _isString } from 'lodash'
...
_isString(myVar)

通过简单的捆绑，您应该没事（我在这里指的是客户端代码）。

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

const util = require('util');
if (util.isString(myVar)) {}

编辑：正如@Jehy所提到的，自v4起不推荐使用。

以下方法将检查是否有任何变量是字符串（包括不存在的变量）。

const is_string = value => {
  try {
    return typeof value() === 'string';
  } catch (error) {
    return false;
  }
};

let example = 'Hello, world!';

console.log(is_string(() => example)); // true
console.log(is_string(() => variable_doesnt_exist)); // false

我还发现它也可以正常工作，并且比其他示例短很多。

if (myVar === myVar + '') {
   //its string
} else {
   //its something else
}

通过连接空引号，它将值转换为字符串。如果myVar已经是一个字符串，则if语句成功。

var a = new String('')
var b = ''
var c = []

function isString(x) {
  return x !== null && x !== undefined && x.constructor === String
}

console.log(isString(a))
console.log(isString(b))
console.log(isString(c))

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

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

const test = x =>
  console.assert
    ( String(x) === x
    , `not a string: ${x}`
    )

test("some string")
test(123)           // assertion failed
test(0)             // assertion failed
test(/some regex/)  // assertion failed
test([ 5, 6 ])      // assertion failed
test({ a: 1 })      // assertion failed
test(x => x + 1)    // assertion failed

同样的技术也适用于数过-

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

const test = x =>
  console.assert
    ( Number(x) === x
    , `not a number: ${x}`
    )

test("some string") // assertion failed
test(123)           
test(0)             
test(/some regex/)  // assertion failed
test([ 5, 6 ])      // assertion failed
test({ a: 1 })      // assertion failed
test(x => x + 1)    // assertion failed

而对于正则表达式 -

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

const test = x =>
  console.assert
    ( RegExp(x) === x
    , `not a regexp: ${x}`
    )

test("some string") // assertion failed
test(123)           // assertion failed
test(0)             // assertion failed
test(/some regex/)  
test([ 5, 6 ])      // assertion failed
test({ a: 1 })      // assertion failed
test(x => x + 1)    // assertion failed

对象相同-

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

注意，正则表达式，数组和函数也被视为对象。

const test = x =>
  console.assert
    ( Object(x) === x
    , `not an object: ${x}`
    )

test("some string") // assertion failed
test(123)           // assertion failed
test(0)             // assertion failed
test(/some regex/)  
test([ 5, 6 ])      
test({ a: 1 })      
test(x => x + 1)    

但是，检查Array有点不同-

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

const test = x =>
  console.assert
    ( Array.isArray(x)
    , `not an array: ${x}`
    )

test("some string") // assertion failed
test(123)           // assertion failed
test(0)             // assertion failed
test(/some regex/)  // assertion failed
test([ 5, 6 ])      
test({ a: 1 })      // assertion failed
test(x => x + 1)    // assertion failed

这种技术并没有对工作职能然而-

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

一个简单的解决方案是：

var x = "hello"

if(x === x.toString()){
// it's a string 
}else{
// it isn't
}

Typechecker助手：

function isFromType(variable, type){
  if (typeof type == 'string') res = (typeof variable == type.toLowerCase())
  else res = (variable.constructor == type)
  return res
}

用法：

isFromType('cs', 'string') //true
isFromType('cs', String) //true
isFromType(['cs'], Array) //true
isFromType(['cs'], 'object') //false

另外，如果您希望它是递归的（例如作为对象的数组），则可以使用 instanceof。

（['cs'] instanceof Object //true）

在这里，我将走另一条路，尝试告诉变量是特定类型还是特定类型集合的成员。
JS建立在鸭嘴式上。如果某些东西像字符串一样嘎嘎响，我们可以并且应该像字符串一样使用它。

是7字符串吗？那为什么/\d/.test(7)行得通呢？
是{toString:()=>('hello there')}字符串吗？那为什么({toString:()=>('hello there')}) + '\ngeneral kenobi!'行得通呢？
这些不是上面的工作应该做的问题，关键是它们确实在做。

因此，我做了一个duckyString()函数
下面，我测试了许多其他答案无法满足的情况。对于每个代码：

• 设置类似字符串的变量
• 对它运行相同的字符串操作，然后对真实的字符串进行比较以比较输出（证明可以将它们视为字符串）
• 将类似字符串的形式转换为真实字符串，以向您展示duckyString()对期望真实字符串的代码的输入进行规范化

text = 'hello there';
out(text.replace(/e/g, 'E') + ' ' + 'hello there'.replace(/e/g, 'E'));
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

text = new String('oh my');
out(text.toUpperCase() + ' ' + 'oh my'.toUpperCase());
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

text = 368;
out((text + ' is a big number') + ' ' + ('368' + ' is a big number'));
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

text = ['\uD83D', '\uDE07'];
out(text[1].charCodeAt(0) + ' ' + '😇'[1].charCodeAt(0));
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

function Text() { this.math = 7; }; Text.prototype = {toString:function() { return this.math + 3 + ''; }}
text = new Text();
out(String.prototype.match.call(text, '0') + ' ' + text.toString().match('0'));
out('Is string? ' + duckyString(text) + '\t"' + duckyString(text, true) + '"\n');

这是同样的!!x，而不是x===true和测试，如果事情是基于阵列状的，而不是迫使实际阵列。
jQuery对象；他们是数组吗？不，他们够好吗？是的，您可以通过Array.prototype功能正常运行它们。
正是这种灵活性赋予了JS强大的功能，并为字符串的专门使您的代码的互操作性降低。

上面的输出是：

hEllo thErE hEllo thErE
Is string? true "hello there"

OH MY OH MY
Is string? true "oh my"

368 is a big number 368 is a big number
Is string? true "368"

56839 56839
Is string? true "😇"

0 0
Is string? true "10"

因此，这就是为什么您想知道某个东西是否是字符串的全部原因。
如果像我一样，您是从Google来到这里的，并且想看看是否是类似字符串的东西，那么这里就是一个答案。
除非您使用的是很长或深度嵌套的char数组，否则它甚至都不昂贵。
这是因为只有if语句，没有像这样的函数调用.toString()。
_{除非您尝试查看一个char数组是否具有仅包含toString()'s或多字节字符的对象，在这种情况下，没有其他方法可以检查字符串，并分别计算字节组成的字符}

function duckyString(string, normalise, unacceptable) {
    var type = null;
    if (!unacceptable)
        unacceptable = {};
    if (string && !unacceptable.chars && unacceptable.to == null)
        unacceptable.to = string.toString == Array.prototype.toString;

    if (string == null)
        ;

    //tests if `string` just is a string
    else if (
        !unacceptable.is &&
        (typeof string == 'string' || string instanceof String)
    )
        type = 'is';

    //tests if `string + ''` or `/./.test(string)` is valid
    else if (
        !unacceptable.to &&
        string.toString && typeof string.toString == 'function' && string.toString != Object.prototype.toString
    )
        type = 'to';

    //tests if `[...string]` is valid
    else if (
        !unacceptable.chars &&
        (string.length > 0 || string.length == 0)
    ) {
        type = 'chars';
        //for each char
        for (var index = 0; type && index < string.length; ++index) {
            var char = string[index];

            //efficiently get its length
            var length = ((duckyString(char, false, {to:true})) ?
                char :
                duckyString(char, true) || {}
            ).length;

            if (length == 1)
                continue;

            //unicode surrogate-pair support
            char = duckyString(char, true);
            length = String.prototype[Symbol && Symbol.iterator];
            if (!(length = length && length.call(char)) || length.next().done || !length.next().done)
                type = null;
        }
    }

    //return true or false if they dont want to auto-convert to real string
    if (!(type && normalise))
        //return truthy or falsy with <type>/null if they want why it's true
        return (normalise == null) ? type != null : type;

    //perform conversion
    switch (type) {
    case 'is':
        return string;
    case 'to':
        return string.toString();
    case 'chars':
        return Array.from(string).join('');
    }
}

包括的选项

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

这是更多测试，因为我是一名完成专家：

out('Edge-case testing')
function test(text, options) {
    var result = duckyString(text, false, options);
    text = duckyString(text, true, options);
    out(result + ' ' + ((result) ? '"' + text + '"' : text));
}
test('');
test(null);
test(undefined);
test(0);
test({length:0});
test({'0':'!', length:'1'});
test({});
test(window);
test(false);
test(['hi']);
test(['\uD83D\uDE07']);
test([['1'], 2, new String(3)]);
test([['1'], 2, new String(3)], {chars:true});

• 所有负面的情况似乎都被解释了
• 这应该在> = IE8的浏览器上运行
• 具有字符串迭代器支持的浏览器支持具有多个字节的Char数组

输出：

Edge-case testing
is ""
null null
null null
to "0"
chars ""
chars "!"
null null
chars ""
to "false"
null null
chars "😇"
chars "123"
to "1,2,3"

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

function isWhitespaceEmptyString(str)
{
    //RETURN:
    //      = 'true' if 'str' is empty string, null, undefined, or consists of white-spaces only
    return str ? !(/\S/.test(str)) : (str === "" || str === null || str === undefined);
}

它还将考虑nulls和undefinedtype，并将处理非字符串类型，例如0。

这对我来说已经足够了。

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

Object.prototype.isString = function() { return false; };
String.prototype.isString = function() { return true; };

var isString = function(a) {
  return (a !== null) && (a !== undefined) && a.isString();
};

您可以像下面这样使用。

//return false
isString(null);
isString(void 0);
isString(-123);
isString(0);
isString(true);
isString(false);
isString([]);
isString({});
isString(function() {});
isString(0/0);

//return true
isString("");
isString(new String("ABC"));

警告：在以下情况下，此方法无法正常工作：

//this is not a string
var obj = {
    //but returns true lol
    isString: function(){ return true; }
}

isString(obj) //should be false, but true

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

var type = function(obj) {
    return Object.prototype.toString.apply(obj).replace(/\[object (.+)\]/i, '$1').toLowerCase();
};

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

type('my string') === 'string' //true
type(new String('my string')) === 'string' //true
type(`my string`) === 'string' //true
type(12345) === 'string' //false
type({}) === 'string' // false

https://codepen.io/patodiblasi/pen/NQXPwY?editors=0012

我不确定您是要知道它的类型是string什么，而不管它的内容是什么，还是内容是数字或字符串，而不管它的类型是什么。

因此，要知道其类型是否为字符串，就已经回答了。
但是要根据其内容知道它是字符串还是数字，我将使用以下代码：

function isNumber(item) {
    return (parseInt(item) + '') === item;
}

还有一些例子：

isNumber(123);   //true
isNumber('123'); //true
isNumber('123a');//false
isNumber('');    //false