Periksa apakah variabel adalah string dalam JavaScript

Bagaimana saya bisa menentukan apakah suatu variabel adalah string atau sesuatu yang lain dalam JavaScript?

Anda dapat menggunakan typeofoperator:

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"

Contoh dari halaman web ini . (Contoh sedikit dimodifikasi).

Ini tidak akan berfungsi seperti yang diharapkan dalam kasus string yang dibuat dengan new String(), tetapi ini jarang digunakan dan direkomendasikan terhadap ^{[1] [2]} . Lihat jawaban lain untuk cara menanganinya, jika diinginkan.

1. Panduan Gaya Google JavaScript mengatakan untuk tidak pernah menggunakan pembungkus objek primitif .
2. Douglas Crockford merekomendasikan agar pembungkus objek primitif tidak digunakan lagi .

Inilah yang bekerja untuk saya:

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

Karena 580+ orang telah memilih jawaban yang salah, dan 800+ telah memilih jawaban yang berfungsi tetapi bergaya senapan, saya pikir mungkin layak untuk mengulang jawaban saya dalam bentuk yang lebih sederhana yang dapat dipahami semua orang.

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

Atau, inline (Saya memiliki pengaturan UltiSnip untuk ini):

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

FYI, jawaban Pablo Santa Cruz salah, karena typeof new String("string")memang begituobject

Jawaban DRAX akurat dan fungsional, dan seharusnya menjadi jawaban yang benar (karena Pablo Santa Cruz jelas salah, dan saya tidak akan berdebat menentang pemilihan umum).

Namun, jawaban ini juga pasti benar, dan sebenarnya jawaban terbaik (kecuali, mungkin, untuk saran menggunakan lodash / garis bawah ). disclaimer: Saya berkontribusi pada basis kode lodash 4.

Jawaban asli saya (yang jelas terbang tepat di atas banyak kepala) berikut:

Saya mentranskode ini dari underscore.js:

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

Itu akan menentukan isString, isNumber, dll.

Di Node.js, ini bisa diimplementasikan sebagai modul:

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

[sunting]: Object.prototype.toString.call(x)berfungsi untuk menggambarkan antara fungsi dan fungsi asink juga:

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

Saya sarankan menggunakan fungsi bawaan dari jQuery atau lodash / Underscore . Mereka lebih mudah digunakan dan lebih mudah dibaca.

Salah satu fungsi akan menangani kasus DRAX yang disebutkan ... yaitu, mereka berdua memeriksa apakah (A) variabel tersebut adalah string literal atau (B) itu adalah turunan dari objek String. Dalam kedua kasus, fungsi-fungsi ini dengan benar mengidentifikasi nilai sebagai 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

Lihat Dokumentasi lodash untuk _.isString () untuk lebih jelasnya.

Lihat Dokumentasi jQuery untuk $ .type () untuk detail lebih lanjut.

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

Saya melihat itu di sini:

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

Cara terbaik:

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

Masing-masing telah dibangun oleh fungsi kelas yang sesuai, seperti "Objek baru ()" dll.

Juga, Bebek Mengetik: "Jika itu terlihat seperti bebek, berjalan seperti bebek, dan baunya seperti bebek - itu pasti sebuah Array" Artinya, periksa propertinya.

Semoga ini membantu.

Edit; 12/05/2016

Ingat, Anda selalu dapat menggunakan kombinasi pendekatan juga. Berikut adalah contoh menggunakan peta tindakan inline dengan typeof :

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

Berikut contoh yang lebih 'dunia nyata' dalam menggunakan inline-maps:

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

Fungsi ini akan menggunakan [custom] "type-casting" - lebih tepatnya, "type - / - value-mapping" - untuk mengetahui apakah suatu variabel benar-benar "ada". Sekarang Anda dapat memisahkan rambut jahat antara null& 0!

Sering kali Anda bahkan tidak peduli dengan tipenya . Cara lain untuk menghindari pengetikan adalah menggabungkan set 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) ...;
}

Keduanya Number.prototype dan String.prototype memiliki .toString() method. Anda hanya memastikan bahwa string-setara dengan nomor itu sama, dan kemudian Anda memastikan bahwa Anda meneruskannya ke dalam httpfungsi sebagai a Number. Dengan kata lain, kami bahkan tidak peduli apa jenisnya.

Harapan yang memberi Anda lebih banyak untuk dikerjakan :)

Jujur saya tidak bisa melihat mengapa orang tidak akan hanya menggunakan typeofdalam kasus ini:

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

Ya itu akan gagal terhadap string yang dibungkus objek (misalnya new String('foo')) tetapi ini secara luas dianggap sebagai praktik yang buruk dan sebagian besar alat pengembangan modern cenderung untuk mencegah penggunaannya. (Jika Anda melihatnya, perbaiki saja!)

The Object.prototype.toStringtrick adalah sesuatu yang semua pengembang front-end telah ditemukan bersalah melakukan satu hari dalam karir mereka tapi jangan biarkan hal itu menipu Anda dengan cat nya pintar: itu akan pecah secepat sesuatu monyet-patch Obyek prototipe:

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

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

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

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

Saya suka menggunakan solusi sederhana ini:

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

Ini adalah contoh bagus mengapa kinerja penting:

Melakukan sesuatu yang sederhana seperti tes untuk sebuah string bisa mahal jika tidak dilakukan dengan benar.

Misalnya, jika saya ingin menulis fungsi untuk menguji apakah ada sesuatu yang berupa string, saya bisa melakukannya dengan salah satu dari dua cara:

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

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

Kedua hal ini sangat lurus ke depan, jadi apa yang bisa berdampak pada kinerja? Secara umum, panggilan fungsi bisa mahal, terutama jika Anda tidak tahu apa yang terjadi di dalam. Pada contoh pertama, ada pemanggilan fungsi ke metode toString Object. Dalam contoh kedua, tidak ada panggilan fungsi, karena typeof dan instanceof adalah operator. Operator jauh lebih cepat daripada panggilan fungsi.

Ketika kinerja diuji, contoh 1 adalah 79% lebih lambat dari contoh 2!

Lihat tes: https://jsperf.com/isstringtype

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

Berfungsi untuk string literal let s = 'blah'dan untuk Object Stringslet s = new String('blah')

Diambil dari 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

Saya pikir solusi @customcommander harus mencukupi dalam 90% kasus Anda:

typeof str === 'string'

Harus melayani Anda dengan benar (hanya karena biasanya tidak ada alasan untuk ada new String('something')dalam kode Anda).

Jika Anda tertarik untuk menangani Stringobjek juga (misalnya Anda mengharapkan beberapa var dari pihak ke-3) kemudian menggunakan lodash seperti yang disarankan @ ClearCloud8 tampaknya seperti solusi yang jelas, sederhana dan elegan.

Namun saya menyarankan untuk berhati-hati dengan perpustakaan seperti lodash karena ukurannya. Alih-alih melakukan

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

Yang membawa seluruh objek lodash besar, saya sarankan sesuatu seperti:

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

Dan dengan bundling sederhana Anda harus baik-baik saja (saya merujuk di sini ke kode klien).

Jika Anda bekerja di lingkungan node.js, Anda cukup menggunakan fungsi built-in isString di utils.

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

Sunting: seperti yang disebutkan @Jehy, ini sudah tidak digunakan lagi sejak v4.

Metode berikut akan memeriksa apakah ada variabel yang berupa string ( termasuk variabel yang tidak ada ).

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

Saya juga menemukan bahwa ini berfungsi dengan baik juga, dan jauh lebih pendek daripada contoh lainnya.

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

Dengan menggabungkan pada kutipan kosong itu mengubah nilai menjadi string. Jika myVarsudah menjadi string maka pernyataan if berhasil.

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

Saya menemukan teknik sederhana ini berguna untuk mengetik-periksa 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

Teknik yang sama juga berfungsi untuk Angka -

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

Dan untuk 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

Sama untuk Objek -

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

NB, regexps, array, dan fungsi juga dianggap objek.

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)    

Tapi, memeriksa Array agak berbeda -

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

Namun teknik ini tidak berfungsi untuk Fungsi -

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

Solusi sederhana adalah:

var x = "hello"

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

Seorang pembantu Typechecker:

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

pemakaian:

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

Juga jika Anda ingin menjadi rekursif (seperti Array yang merupakan Obyek), Anda dapat menggunakan instanceof.

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

Saya akan pergi ke rute yang berbeda ke yang lain di sini, yang mencoba untuk mengetahui apakah suatu variabel adalah spesifik, atau anggota dari set tertentu, jenis.
JS dibangun di atas ducktyping; jika sesuatu berdetak seperti string, kita bisa dan harus menggunakannya seperti string.

Apakah 7sebuah string? Lalu mengapa /\d/.test(7)berhasil?
Apakah {toString:()=>('hello there')}sebuah string? Lalu mengapa ({toString:()=>('hello there')}) + '\ngeneral kenobi!'berhasil?
Ini bukan pertanyaan tentang apakah pekerjaan di atas, intinya adalah mereka melakukannya.

Jadi saya membuat duckyString()fungsi
Di bawah ini saya menguji banyak kasus yang tidak dipenuhi oleh jawaban lain. Untuk setiap kode:

• menetapkan variabel seperti string
• menjalankan operasi string yang identik di atasnya dan string nyata untuk membandingkan output (membuktikan bahwa mereka dapat diperlakukan seperti string)
• mengonversi string-like menjadi string nyata untuk menunjukkan duckyString()kepada Anda untuk menormalkan input untuk kode yang mengharapkan string nyata

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

Ini berada dalam nada yang sama !!xsebagai lawan x===truedan menguji apakah ada sesuatu yang seperti array bukan memerlukan array yang sebenarnya.
objek jQuery; apakah mereka array? Tidak. Apakah mereka cukup baik? Ya, Anda dapat menjalankannya melalui Array.prototypefungsi dengan baik.
Fleksibilitas inilah yang memberi JS kekuatannya, dan pengujian untuk string secara spesifik membuat kode Anda kurang dapat dioperasikan.

Output di atas adalah:

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"

Jadi, ini semua tentang mengapa Anda ingin tahu apakah ada masalah.
Jika, seperti saya, Anda tiba di sini dari google dan ingin melihat apakah ada sesuatu yang mirip string , inilah jawabannya.
Itu bahkan tidak mahal kecuali jika Anda bekerja dengan array char sangat panjang atau sangat bersarang.
Ini karena itu semua jika pernyataan, tidak ada fungsi panggilan suka .toString().
_{Kecuali jika Anda mencoba untuk melihat apakah array char dengan objek yang hanya memiliki toString()karakter multi-byte, dalam hal ini tidak ada cara lain untuk memeriksa kecuali untuk membuat string, dan menghitung karakter byte, masing-masing.}

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

Termasuk pilihan untuk

• tanyakan metode mana yang dianggap sebagai string-y
• kecualikan metode deteksi string (mis. jika Anda tidak suka .toString())

Berikut ini lebih banyak tes karena saya seorang penyelesaian:

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

• Semua kasus negatif tampaknya diperhitungkan
• Ini harus dijalankan di browser> = IE8
• Array array dengan beberapa byte yang didukung pada browser dengan dukungan string iterator

Keluaran:

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"

Hanya untuk memperluas jawaban @ DRAX , saya akan melakukan ini:

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

Ini akan memperhitungkan juga untuk nulls dan undefinedtipe, dan itu akan menangani tipe non-string, seperti 0.

Ini cukup baik untukku.

PERINGATAN: Ini bukan solusi yang sempurna. Lihat bagian bawah posting saya.

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

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

Dan Anda bisa menggunakan ini seperti di bawah ini.

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

PERINGATAN: Ini berfungsi salah dalam hal:

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

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

Anda dapat menggunakan fungsi ini untuk menentukan jenis apa pun:

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

Untuk memeriksa apakah suatu variabel adalah string:

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

Saya tidak yakin apakah maksud Anda mengetahui apakah itu tipe stringterlepas dari isinya, atau apakah isinya angka atau string, terlepas dari jenisnya.

Jadi untuk mengetahui apakah tipenya adalah string, itu sudah dijawab.
Tetapi untuk mengetahui berdasarkan isinya jika berupa string atau angka, saya akan menggunakan ini:

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

Dan untuk beberapa contoh:

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