Kiểm tra xem một biến có phải là một chuỗi trong JavaScript không

Làm cách nào để xác định xem một biến là một chuỗi hay thứ gì khác trong JavaScript?

Bạn có thể sử dụng typeoftoán tử:

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"

Ví dụ từ trang web này . (Ví dụ đã được sửa đổi một chút).

Điều này sẽ không hoạt động như mong đợi trong trường hợp các chuỗi được tạo bằng new String(), nhưng điều này hiếm khi được sử dụng và được đề xuất đối với ^{[1] [2]} . Xem các câu trả lời khác để biết cách xử lý những điều này, nếu bạn rất mong muốn.

1. Hướng dẫn Phong cách Google JavaScript nói không bao giờ sử dụng trình bao bọc đối tượng nguyên thủy .
2. Douglas Crockford khuyến nghị các trình bao bọc đối tượng nguyên thủy không được chấp nhận .

Đây là những gì làm việc cho tôi:

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

Vì hơn 580 người đã bỏ phiếu cho một câu trả lời không chính xác và hơn 800 người đã bỏ phiếu cho một câu trả lời theo kiểu shotgun hoạt động, tôi nghĩ rằng nó có thể đáng để làm lại câu trả lời của tôi ở dạng đơn giản hơn mà mọi người có thể hiểu.

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

Hoặc, nội tuyến (Tôi có thiết lập UltiSnip cho việc này):

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

FYI, câu trả lời Pablo Santa Cruz là sai, vì typeof new String("string")làobject

Câu trả lời của DRAX là chính xác và đầy đủ chức năng, và phải là câu trả lời chính xác (vì Pablo Santa Cruz chắc chắn là không chính xác và tôi sẽ không tranh luận về việc bỏ phiếu phổ biến.)

Tuy nhiên, câu trả lời này cũng hoàn toàn chính xác và thực sự là câu trả lời tốt nhất (ngoại trừ, có lẽ, đối với gợi ý sử dụng lodash / gạch dưới ). từ chối trách nhiệm: Tôi đã đóng góp cho lodash 4 codebase.

Câu trả lời ban đầu của tôi (rõ ràng đã bay qua rất nhiều đầu) sau:

Tôi đã chuyển mã này từ underscore.js:

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

Điều đó sẽ xác định isString, isNumber, v.v.

Trong Node.js, điều này có thể được triển khai dưới dạng một mô-đun:

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

[sửa]: cũng Object.prototype.toString.call(x)hoạt động để phân định giữa các chức năng và chức năng không đồng bộ:

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))

Tôi khuyên bạn nên sử dụng các hàm dựng sẵn từ jQuery hoặc lodash / Underscore . Chúng đơn giản hơn để sử dụng và dễ đọc hơn.

Cả hai hàm sẽ xử lý trường hợp DRAX được đề cập ... nghĩa là cả hai đều kiểm tra xem (A) biến đó có phải là một chuỗi bằng chữ hay (B) nó là một thể hiện của đối tượng String. Trong cả hai trường hợp, các hàm này xác định chính xác giá trị là một chuỗi.

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

Xem Tài liệu lodash cho _.isString () để biết thêm chi tiết.

Xem Tài liệu jQuery cho $ .type () để biết thêm chi tiết.

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

Tôi thấy điều đó ở đây:

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

Cách tốt nhất:

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');

Mỗi trong số này đã được xây dựng bởi hàm lớp thích hợp của nó, như "Object mới ()", v.v.

Ngoài ra, Duck-Typing: "Nếu nó trông giống như một con vịt, đi giống như một con vịt và có mùi giống như một con vịt - đó phải là một mảng" Ý nghĩa, hãy kiểm tra các thuộc tính của nó.

Hi vọng điêu nay co ich.

Biên tập; 12/05/2016

Hãy nhớ rằng, bạn luôn có thể sử dụng kết hợp các phương pháp tiếp cận quá. Đây là một ví dụ về việc sử dụng bản đồ hành động nội tuyến với typeof :

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

Đây là một ví dụ 'thế giới thực' hơn về việc sử dụng bản đồ nội tuyến:

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

Hàm này sẽ sử dụng [tùy chỉnh] "kiểu đúc" - thay vào đó là "kiểu - / - ánh xạ giá trị" - để tìm hiểu xem một biến có thực sự "tồn tại" hay không. Bây giờ bạn có thể chia mái tóc khó chịu đó giữa null& 0!

Nhiều khi bạn thậm chí không quan tâm đến loại của nó . Một cách khác để tránh gõ là kết hợp các bộ 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) ...;
}

Cả hai Number.prototype và String.prototype có một .toString() method. Bạn chỉ cần đảm bảo rằng chuỗi tương đương của số là giống nhau, và sau đó bạn chắc chắn rằng bạn đã chuyển nó vàohttp hàm dưới dạng a Number. Nói cách khác, chúng tôi thậm chí không quan tâm loại của nó là gì.

Hy vọng rằng cung cấp cho bạn nhiều hơn để làm việc với :)

Tôi không thể thành thật nhìn thấy lý do tại sao một người sẽ không đơn giản sử dụng typeoftrong trường hợp này:

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

Có, nó sẽ thất bại trước các chuỗi được bọc đối tượng (ví dụ new String('foo')) nhưng chúng được coi là một thực tiễn xấu và hầu hết các công cụ phát triển hiện đại có khả năng không khuyến khích sử dụng chúng. (Nếu bạn thấy một cái, chỉ cần sửa nó!)

Thủ Object.prototype.toStringthuật này là thứ mà tất cả các nhà phát triển front-end đã bị kết tội là làm một ngày trong sự nghiệp của họ nhưng đừng để nó đánh lừa bạn bởi sự thông minh của nó: nó sẽ phá vỡ ngay khi một thứ gì đó khắc phục nguyên mẫu Object:

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

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

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

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

Tôi thích sử dụng giải pháp đơn giản này:

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

Đây là một ví dụ tuyệt vời về lý do tại sao hiệu suất quan trọng:

Làm một cái gì đó đơn giản như một bài kiểm tra cho một chuỗi có thể tốn kém nếu không được thực hiện đúng.

Ví dụ, nếu tôi muốn viết một hàm để kiểm tra xem có thứ gì đó là một chuỗi không, tôi có thể thực hiện nó theo một trong hai cách:

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

2) const isString = str => ((typeof str === 'string') || (str instanceof String));

Cả hai đều khá thẳng về phía trước, vậy điều gì có thể ảnh hưởng đến hiệu suất? Nói chung, các cuộc gọi chức năng có thể tốn kém, đặc biệt nếu bạn không biết những gì đang xảy ra bên trong. Trong ví dụ đầu tiên, có một lệnh gọi hàm đến phương thức toString của Object. Trong ví dụ thứ hai, không có lệnh gọi hàm nào, vì typeof và instanceof là toán tử. Các nhà khai thác nhanh hơn đáng kể so với các cuộc gọi chức năng.

Khi hiệu suất được kiểm tra, ví dụ 1 chậm hơn 79% so với ví dụ 2!

Xem các bài kiểm tra: https://jsperf.com/isopestype

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

Hoạt động cho cả chuỗi ký tự let s = 'blah'và chuỗi đối tượnglet s = new String('blah')

Lấy từ 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

Tôi nghĩ rằng giải pháp @customcommander sẽ đủ cho 90% trường hợp của bạn:

typeof str === 'string'

Nên phục vụ bạn ngay (đơn giản vì bình thường không có lý do để có new String('something') mã của bạn).

Nếu bạn quan tâm đến việc xử lý String đối tượng (ví dụ: bạn mong đợi một số var từ bên thứ 3) thì sử dụng lodash như @ ClearCloud8 có vẻ như là một giải pháp rõ ràng, đơn giản và thanh lịch.

Tuy nhiên tôi sẽ đề nghị thận trọng với các thư viện như lodash do kích thước của chúng. Thay vì làm

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

Điều này mang lại toàn bộ đối tượng lodash lớn, tôi muốn đề xuất một cái gì đó như:

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

Và với gói đơn giản, bạn sẽ ổn (tôi tham khảo mã khách hàng ở đây).

Nếu bạn làm việc trên môi trường node.js, bạn chỉ cần sử dụng hàm tích hợp isString in utils.

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

Chỉnh sửa: như @Jehy đã đề cập, điều này không được chấp nhận kể từ v4.

Phương thức sau đây sẽ kiểm tra xem có bất kỳ biến nào là một chuỗi không ( bao gồm các biến không tồn tại ).

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

Tôi cũng thấy rằng điều này cũng hoạt động tốt, và nó ngắn hơn rất nhiều so với các ví dụ khác.

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

Bằng cách nối vào các trích dẫn trống, nó biến giá trị thành một chuỗi. Nếu myVarđã là một chuỗi thì câu lệnh if thành công.

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))

Tôi thấy kỹ thuật đơn giản này hữu ích để kiểm tra kiểu cho String -

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

Kỹ thuật tương tự cũng hoạt động với Number -

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

Và cho RegExp -

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

Tương tự cho Object -

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

NB, regexps, mảng và hàm cũng được coi là đối tượng.

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)    

Nhưng, kiểm tra Array thì hơi khác một chút -

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

Kỹ thuật này không hoạt động cho Hàm tuy nhiên -

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

Một giải pháp đơn giản sẽ là:

var x = "hello"

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

Một người trợ giúp đánh máy chữ:

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

sử dụng:

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

Ngoài ra nếu bạn muốn nó được đệ quy (như Array là Object), bạn có thể sử dụng instanceof .

( ['cs'] instanceof Object //true)

Tôi sẽ đi một tuyến đường khác với phần còn lại ở đây, cố gắng cho biết một biến là một cụ thể hay một thành viên của một tập hợp cụ thể, các loại.
JS được xây dựng trên vịt; nếu một cái gì đó giống như một chuỗi, chúng ta có thể và nên sử dụng nó như một chuỗi.

Là 7một chuỗi? Vậy thì tại sao lại /\d/.test(7)làm việc?
Là {toString:()=>('hello there')}một chuỗi? Vậy thì tại sao lại ({toString:()=>('hello there')}) + '\ngeneral kenobi!'làm việc?
Đây không phải là câu hỏi về nên công việc trên, điểm mấu chốt là họ làm.

Vì vậy, tôi đã thực hiện một duckyString()chức năng
Dưới đây tôi kiểm tra nhiều trường hợp không phục vụ cho các câu trả lời khác. Đối với mỗi mã:

• đặt một biến giống như chuỗi
• chạy một hoạt động chuỗi giống hệt nhau trên nó và một chuỗi thực để so sánh các đầu ra (chứng minh rằng chúng có thể được coi như các chuỗi)
• chuyển đổi chuỗi giống như chuỗi thành chuỗi thực để hiển thị cho bạn duckyString()chuẩn hóa đầu vào cho mã mong đợi chuỗi thực

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');

Điều này nằm trong cùng một hướng !!xđối lập x===truevà kiểm tra nếu một cái gì đó giống như mảng thay vì bắt buộc một mảng thực tế.
Các đối tượng jQuery; chúng là mảng? Không. Họ có đủ tốt không? Vâng, bạn có thể chạy chúng thông qua các Array.prototypechức năng tốt.
Chính sự linh hoạt này mang lại cho JS sức mạnh của nó và việc kiểm tra các chuỗi đặc biệt làm cho mã của bạn ít tương tác hơn.

Đầu ra của ở trên là:

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"

Vì vậy, đó là tất cả về lý do tại sao bạn muốn biết nếu một cái gì đó là một chuỗi.
Nếu, giống như tôi, bạn đến đây từ google và muốn xem liệu có thứ gì đó giống chuỗi không , đây là câu trả lời.
Nó thậm chí không đắt tiền trừ khi bạn làm việc với các mảng char thực sự dài hoặc được lồng sâu.
Điều này là bởi vì tất cả là câu lệnh if, không có hàm nào gọi như thế .toString().
_{Ngoại trừ nếu bạn đang cố gắng xem liệu một mảng char có các đối tượng chỉ có toString()các ký tự nhiều byte hay không, trong trường hợp đó không có cách nào khác để kiểm tra ngoại trừ tạo chuỗi và đếm các ký tự mà byte tạo thành, tương ứng}

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('');
    }
}

Bao gồm các tùy chọn để

• hỏi phương thức nào được coi là chuỗi-y
• loại trừ các phương pháp phát hiện chuỗi (ví dụ: nếu bạn không thích .toString())

Dưới đây là nhiều bài kiểm tra hơn vì tôi là người hoàn thành:

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});

• Tất cả các trường hợp tiêu cực dường như được tính đến
• Điều này sẽ chạy trên trình duyệt> = IE8
• Các mảng Char có nhiều byte được hỗ trợ trên các trình duyệt có hỗ trợ chuỗi lặp

Đầu ra:

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"

Chỉ cần mở rộng câu trả lời của @ DRAX , tôi sẽ làm điều này:

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);
}

Nó cũng sẽ tính đến nulls và undefinedcác loại, và nó sẽ chăm sóc các loại không phải chuỗi, chẳng hạn như 0.

Điều này là đủ tốt cho tôi.

CẢNH BÁO: Đây không phải là một giải pháp hoàn hảo. Xem dưới cùng của bài viết của tôi.

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

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

Và bạn có thể sử dụng như thế này dưới đây.

//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"));

CẢNH BÁO: Điều này hoạt động không chính xác trong trường hợp:

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

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

Bạn có thể sử dụng chức năng này để xác định loại của bất cứ điều gì:

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

Để kiểm tra xem một biến có phải là một chuỗi không:

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

Tôi không chắc nếu bạn muốn biết đó là loại stringbất kể nội dung của nó hay nội dung của nó là số hay chuỗi, bất kể loại đó là gì.

Vì vậy, để biết loại của nó là một chuỗi, điều đó đã được trả lời.
Nhưng để biết dựa trên nội dung của nó nếu đó là một chuỗi hoặc một số, tôi sẽ sử dụng điều này:

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

Và cho một số ví dụ:

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