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 명 이상이 효과가 있지만 샷건 스타일 답변에 투표 했으므로 모든 사람이 이해할 수있는 더 간단한 형태로 답을 다시 작성하는 것이 좋습니다.

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

[편집] : 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

_.isString ()에 대한 lodash 설명서를 참조하십시오. 대한 참조하십시오.

자세한 내용 은 $ .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 월 5 일

항상 접근 방식 조합을 사용할 수 있습니다. 다음 은 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] "type-casting"대신 "type-/-value-mapping"을 사용하여 변수가 실제로 "존재하는지"알아냅니다. 이제 불쾌한 머리카락을 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함수에 a 로 전달했는지 확인 했습니다 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객체를 (예 : 타사의 var를 기대하십시오) @ ClearCloud8이 제안한대로 lodash를 사용하면 명확하고 간단하며 우아한 솔루션처럼 보입니다.

그러나 크기 때문에 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)) {}

편집 : @ Jee가 언급했듯이 이것은 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이미 문이 성공 인 경우 다음 문자열입니다.

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 에도 적용됩니다.

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의 경우 -

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

NB, 정규 표현식, 배열 및 함수도 객체로 간주됩니다.

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.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
}

유형 검사기 도우미 :

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

또한 재귀 적으로 만들고 싶다면 (예 : Object 인 Array)을 사용할 수 있습니다 instanceof.

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

변수가 특정 유형인지 또는 특정 유형의 유형인지 여부를 알려주는 나머지 경로로 이동합니다.
JS는 ducktyping을 기반으로합니다. 무언가가 문자열처럼 cks 경우, 문자열처럼 사용할 수 있고 사용해야합니다.

가 7문자열? 그렇다면 왜 /\d/.test(7)작동합니까?
가 {toString:()=>('hello there')}문자열? 그렇다면 왜 ({toString:()=>('hello there')}) + '\ngeneral kenobi!'작동합니까?
이들에 대한 질문이 없습니다 SHOULD 위의 작품은, 요점은 그들이 할 수 있습니다.

그래서 내가 만든 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것과는 정반대 입니다. jQuery 객체; 그것들은 배열입니까? 아뇨. 충분 해요? 예, 기능을 통해 제대로 실행할 수 있습니다 . JS에 강력한 기능을 제공 하고 문자열을 테스트 하면 코드의 상호 운용성이 떨어집니다.x===true
Array.prototype

위의 결과는 다음과 같습니다.

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"

따라서 문자열이 무엇인지 알고 싶은 이유 가 전부 입니다.
나처럼, 당신이 구글에서 여기에 도착하여 문자열 같은 것이 있는지 알고 싶다면 여기에 답이 있습니다.
실제로 길거나 깊게 중첩 된 char 배열로 작업하지 않는 한 비싸지 않습니다.
모든 if 문이기 때문에 같은 함수 호출이 없기 때문입니다 .toString(). _{의 또는 멀티 바이트 문자
만있는 객체가있는 char 배열을 확인하려는 경우를 제외하고 toString()는 문자열을 만드는 것 외에는 확인할 다른 방법이 없으며 바이트를 구성하는 문자 수를 각각 계산하십시오}

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에서 실행되어야합니다.
• 문자열 반복자를 지원하는 브라우저에서 다중 바이트를 지원하는 문자 배열

산출:

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 및 undefined유형을 고려하고와 같이 문자열이 아닌 유형을 처리 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