javascript中检查变量是否为字符串


Check if a variable is a string in JavaScript

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

这就是我的工作：

1
2
3
4
if (typeof myVar === 'string' || myVar instanceof String)
// it's a string
else
// it's something else
相关讨论

您可以使用typeof运算符：

1
2
3
4
5
6
7
8
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]。如果您愿意，请参阅其他答案以了解如何处理这些问题。

  • 谷歌javascript风格指南说永远不要使用原始对象包装器。
  • 道格拉斯·克罗克福德建议不要使用原始对象包装器。
    • 相关讨论

    既然有580多人投票赞成一个错误的答案，800多人投票赞成一个有效但枪炮式的答案，我认为以一种大家都能理解的简单形式重做我的答案是值得的。

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

    或者，内联(我对此有一个ultisnip设置)：

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

    拜托，帕布罗·圣克鲁斯的回答是错误的，因为埃多克斯1〔9〕是埃多克斯1〔10〕。

    德拉克斯的回答是准确和实用的，应该是正确的答案(因为帕布罗·圣克鲁斯绝对是错误的，我不会反对大众的投票。)

    然而，这个答案也是绝对正确的，而且实际上是最好的答案(可能除了建议使用lodash/下划线)。免责声明：我贡献了洛达什4代码库。

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

    我从underline.js转码：

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

    这将定义IsString、IsNumber等。

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    module.exports = [
      'Arguments',
      'Function',
      'String',
      'Number',
      'Date',
      'RegExp'
    ].reduce( (obj, name) => {
      obj[ 'is' + name ] = x => toString.call(x) == '[object ' + name + ']';
      return obj;
    }, {});
    相关讨论

    我建议使用jquery或lodash/underline中的内置函数。它们使用起来更简单，也更容易阅读。

    任何一个函数都将处理所提到的DRAX情况…也就是说，它们都检查(a)变量是字符串文字还是(b)它是字符串对象的实例。在这两种情况下，这些函数都正确地将值标识为字符串。

    lodash/下划线.js

    1
    2
    3
    4
    if(_.isString(myVar))
       //it's a string
    else
       //it's something else

    JQuery

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

    有关详细信息，请参阅lodash文档以获取.isstring()。

    有关更多详细信息，请参阅jquery文档中的$.type()。

    相关讨论

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

    我在这里看到了：

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

    相关讨论

    最佳方式：

    1
    2
    3
    4
    5
    6
    7
    8
    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输入：如果它看起来像一只鸭子，走路像一只鸭子，闻起来像一只鸭子，那一定是一个阵列。意思是，检查它的属性。

    希望这有帮助。

    编辑：12/05/2016

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

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

    下面是使用内联映射的更"真实"的示例：

    1
    2
    3
    4
    5
    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

    此函数将使用[自定义]"类型转换"(而不是"类型-值映射")来确定变量是否实际"存在"。现在你可以把那讨厌的头发分给null和0！

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

    1
    2
    3
    4
    5
    6
    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。您只需确保与数字等效的字符串是相同的，然后确保将其作为Number传递到http函数中。换句话说，我们甚至不在乎它的类型。

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

    相关讨论

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

    1
    2
    3
    4
    5
    var myString ="test";
    if(myString.constructor === String)
    {
         //It's a string
    }
    相关讨论

    我真的不明白为什么在这种情况下人们不简单地使用typeof：

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

    是的，它对对象包装的字符串(如new String('foo'))会失败，但这些被广泛认为是一种糟糕的实践，大多数现代开发工具可能会阻碍它们的使用。(如果你看到了，就把它修好！)

    Object.prototype.toString技巧是所有前端开发人员都被发现在他们的职业生涯中有一天会犯下的错误，但不要让它用它的聪明来愚弄你：一旦猴子修补了对象原型，它就会崩溃：

    1
    2
    3
    4
    5
    6
    7
    const isString = thing => Object.prototype.toString.call(thing) === '[object String]';

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

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

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

    取自罗达什：

    1
    2
    3
    4
    5
    6
    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

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

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

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

    1)江户十一〔1〕号

    2)江户十一〔2〕

    这两个方面都是非常直接的，那么什么可能影响性能呢？一般来说，函数调用可能很昂贵，特别是如果您不知道内部发生了什么。在第一个示例中，有一个对对象的ToString方法的函数调用。在第二个示例中，没有函数调用，因为typeof和instanceof是运算符。运算符比函数调用快得多。

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

    请参见测试：https://jspef.com/isstringtype

    相关讨论

    如果您在node.js环境中工作，您可以简单地使用内置函数isString-in-utils。

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

    编辑：正如@jehy所提到的，这是自v4以来被否决的。

    相关讨论

    我还发现这个方法也很有效，而且比其他例子短得多。

    1
    2
    3
    4
    5
    if (myVar === myVar + '') {
       //its string
    } else {
       //its something else
    }

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

    相关讨论

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    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))
    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    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

    一个简单的解决方案是：

    1
    2
    3
    4
    5
    6
    7
    var x ="hello"

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

    为了进一步了解@drax的答案，我会这样做：

    1
    2
    3
    4
    5
    6
    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);
    }

    它还将解释null和undefined类型，并将处理非字符串类型，如0。

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

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

    这对我来说已经足够好了。

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

    1
    2
    3
    4
    5
    6
    Object.prototype.isString = function() { return false; };
    String.prototype.isString = function() { return true; };

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

    你可以这样使用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    //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"));

    警告：这在以下情况下工作不正确：

    1
    2
    3
    4
    5
    6
    7
    //this is not a string
    var obj = {
        //but returns true lol
        isString: function(){ return true; }
    }

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

    我不确定你的意思是知道它是否是string类型，不管它的内容是什么，或者它的内容是数字还是字符串，不管它的类型是什么。所以为了知道它的类型是否是字符串，已经回答过了。但为了根据它的内容知道它是一个字符串还是一个数字，我将使用这个：

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

    例如：

    1
    2
    3
    4
    isNumber(123);   //true
    isNumber('123'); //true
    isNumber('123a');//false
    isNumber('');    //false
    相关讨论