විචල්‍යය ජාවාස්ක්‍රිප්ට් හි නූලක් දැයි පරීක්ෂා කරන්න

ජාවාස්ක්‍රිප්ට් හි විචල්‍යයක් නූල් හෝ වෙනත් දෙයක් දැයි මම තීරණය කරන්නේ කෙසේද?

ඔබට 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. ගූගල් ජාවාස්ක්‍රිප්ට් ස්ටයිල් ගයිඩ් පවසන්නේ කිසි විටෙකත් ප්‍රාථමික වස්තු ආවරණ භාවිතා නොකරන ලෙසයි .
2. ඩග්ලස් ක්‍රොක්ෆර්ඩ් නිර්දේශ කළේ ප්‍රාථමික වස්තු ආවරණ ඉවත් කළ යුතු බවයි .

මෙය මට ප්‍රයෝජනවත් වන්නේ:

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]"
}

නැතහොත්, පේළියේ (මට මේ සඳහා අල්ටිස්නිප් සැකසුමක් ඇත):

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

FYI, පැබ්ලෝ සැන්ටා ක ru ස්ගේ පිළිතුර වැරදියි, මන්ද typeof new String("string") කියන්නේobject

ඩ්‍රැක්ස්ගේ පිළිතුර නිවැරදි හා ක්‍රියාකාරී වන අතර එය නිවැරදි පිළිතුර විය යුතුය (පැබ්ලෝ සැන්ටා ක ru ස් නිසැකවම වැරදියි, මම ජනප්‍රිය ඡන්දයට එරෙහිව තර්ක නොකරමි.)

කෙසේ වෙතත්, මෙම පිළිතුර ද නියත වශයෙන්ම නිවැරදි වන අතර ඇත්ත වශයෙන්ම හොඳම පිළිතුර (සමහර විට, ලොඩාෂ් / යටි ඉරි ලකුණු භාවිතා කිරීම හැර ).වියාචනය: මම ලොඩාෂ් 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) එය සංගීත වස්තුවේ උදාහරණයක්ද යන්න පරීක්ෂා කරයි. කෙසේ වෙතත්, මෙම ශ්‍රිතයන් අගය නිවැරදිව හඳුනා ගනී.

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 () සඳහා ලොඩාෂ් ප්‍රලේඛනය බලන්න .

වැඩි විස්තර සඳහා j .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');

මේ සෑම එකක්ම "නව වස්තුව ()" වැනි සුදුසු පන්ති ක්‍රියාකාරිත්වය මගින් ගොඩනගා ඇත.

එසේම, තාරා-ටයිප් කිරීම: "එය තාරාවෙකු මෙන් පෙනේ නම්, තාරාවෙකු මෙන් ඇවිදින අතර, තාරාවෙකු මෙන් සුවඳයි - එය අරාව විය යුතුය" අර්ථය, එහි ගුණාංග පරීක්ෂා කරන්න.

මෙය උපකාරී වේ යැයි සිතමි.

සංස්කරණය කරන්න; 12/05/2016

මතක තබා ගන්න, ඔබට සැමවිටම ප්‍රවේශයන්ගේ සංයෝජන භාවිතා කළ හැකිය. 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

විචල්‍යයක් ඇත්ත වශයෙන්ම "පවතී" දැයි සොයා ගැනීමට මෙම ශ්‍රිතය [අභිරුචි] "ටයිප්-කාස්ටිං" - ඒ වෙනුවට "ටයිප් - / - අගය-සිතියම්කරණය" භාවිතා කරයි. දැන් ඔබට එම නපුරු කොණ්ඩය null& 0!

බොහෝ විට ඔබ එහි වර්ගය ගැන තැකීමක් නොකරයි . ටයිප් කිරීම වළක්වා ගත හැකි තවත් ක්‍රමයක් නම් තාරා වර්ගයේ කට්ටල ඒකාබද්ධ කිරීමයි:

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 a .toString() method. අංකයට සමාන නූල් සමාන බව ඔබ සහතික කර ගත් අතර, ඔබ එය httpa ලෙස ශ්‍රිතයට ඇතුළත් කිරීමට වග බලා ගත්තේය 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's toString ක්‍රමයට ක්‍රියාකාරී ඇමතුමක් ඇත. දෙවන උදාහරණයේ දී, ක්‍රියාකාරී ඇමතුම් නොමැත, යතුරු ලියනය සහ නිදර්ශන ක්‍රියාකරුවන් බැවින්. ක්‍රියාකරුවන් ඇමතුම් වලට වඩා සැලකිය යුතු වේගයකින් ක්‍රියා කරයි.

කාර්ය සාධනය පරීක්ෂා කළ විට, උදාහරණ 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')

ලොඩාෂ් වලින් ගත්:

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

මෙයද හොඳින් ක්‍රියාත්මක වන බවත් අනෙක් උදාහරණවලට වඩා එය ඉතා කෙටි බවත් මම සොයා ගතිමි.

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

හිස් මිල ගණන් සමඟ සංක්ෂිප්ත කිරීමෙන් එය අගය නූලක් බවට පත් කරයි. නම් myVarමේ වන විටත් වැලක් පසුව නම් ප්රකාශය සාර්ථක වේ.

ඔබගේ නඩු වලින් 90% ක් සඳහා @customcommander විසඳුම ප්‍රමාණවත් යැයි මම සිතමි:

typeof str === 'string'

ඔබට නිවැරදිව සේවය කළ යුතුය (සාමාන්‍යයෙන් new String('something')ඔබේ කේතයේ කිසිදු හේතුවක් නොමැති බැවින් ).

ඔබ Stringවස්තුව හැසිරවීමට උනන්දුවක් දක්වන්නේ නම් (නිදසුනක් ලෙස ඔබ තෙවන පාර්ශවයකින් යම් ප්‍රභේදයක් බලාපොරොත්තු වේ) එවිට lodash @ ClearCloud8 ලෙස භාවිතා කිරීම පැහැදිලි, සරල හා අලංකාර විසඳුමක් සේ පෙනේ.

කෙසේ වෙතත්, ලොඩාෂ් වැනි පුස්තකාලවල ප්‍රමාණය නිසා ප්‍රවේශම් වන්නැයි මම යෝජනා කරමි. කරනවා වෙනුවට

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

එමඟින් විශාල ලොඩාෂ් වස්තුව ගෙන එනු ඇත, මම මෙවැනි දෙයක් යෝජනා කරමි:

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

සරල බැඳීමකින් ඔබ හොඳින් විය යුතුය (මම මෙහි යොමු කරන්නේ සේවාදායක කේතය වෙත).

ඔබ node.js පරිසරය මත වැඩ කරන්නේ නම්, ඔබට හුදෙක් බිල්ට් ශ්‍රිතය භාවිතා කළ හැකිය isString in utils.

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

සංස්කරණය කරන්න: @ ජේහි සඳහන් කළ පරිදි, මෙය 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

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 සඳහා ටයිප් කිරීම සඳහා මෙම සරල තාක්ෂණය ප්‍රයෝජනවත් බව මට පෙනේ -

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 සඳහා -

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

එසේම එය පුනරාවර්තන වීමට ඔබට අවශ්‍ය නම් (අරාව වස්තුවක් වැනි), ඔබට භාවිතා කළ හැකිය instanceof .

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

මම මෙහි ඉතිරි කොටස වෙත වෙනත් මාර්ගයකට යන්නෙමි, එය විචල්‍යයක් නිශ්චිතද, නැතහොත් නිශ්චිත කට්ටලයක සාමාජිකද යන්න පැවසීමට උත්සාහ කරයි.
ජේඑස් ගොඩනඟා ඇත්තේ තාරාවන් මත ය; යම් දෙයක් නූල් වැනි දෙයක් නම්, අපට එය නූල් මෙන් භාවිතා කළ හැකිය.

වන 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යමක් array- නම් සහ පරීක්ෂා වගේ සත්ය මාලාවක් සැලසුම් කර වෙනුවට.
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"

ඉතින්, ඒ සියල්ල ඔබට යමක් දැන ගැනීමට අවශ්‍ය වන්නේ ඇයිද යන්න ගැන ය .
මා වැනි, ඔබ ගූගල් වෙතින් මෙහි පැමිණ යමක් නූල් වැනි දැයි බැලීමට අවශ්‍ය නම් , මෙන්න පිළිතුරක්.
ඔබ දිගු හෝ ගැඹුරින් කැදැලි කරල් අරා සමඟ වැඩ කරන්නේ නම් මිස එය මිල අධික නොවේ.
මෙයට හේතුව ප්‍රකාශ සියල්ලම නම්, කිසිදු ශ්‍රිතයක් කැඳවන්නේ නැත .toString().
_{හැරෙන්නට ඔබ උත්සාහ කරන්නේ නම්, වර්‍ග 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('');
    }
}

සඳහා විකල්ප ඇතුළත් වේ

• එය string-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});

• සියලුම negative ණාත්මක සිද්ධීන් සඳහා වගකිව යුතු බව පෙනේ
• මෙය බ්‍රව්සර් මත ක්‍රියාත්මක විය යුතුය> = 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"

@ ඩ්‍රැක්ස්ගේ පිළිතුර පුළුල් කිරීම සඳහා , මම මෙය කරන්නෙමි:

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

වෙනත් වර්ග පරීක්ෂා කිරීම සඳහා:

type(null) //null
type(undefined) //undefined
type([]) //array
type({}) //object
type(function() {}) //function
type(123) //number
type(new Number(123)) //number
type(/some_regex/) //regexp
type(Symbol("foo")) //symbol

stringඑහි අන්තර්ගතය නොසලකා එය වර්ගයක්ද, නැතහොත් එහි අන්තර්ගතය අංකයක් හෝ නූලක්ද යන්න දැන ගැනීම අදහස් කරන්නේ දැයි මට විශ්වාස නැත .

එබැවින් එහි වර්ගය නූලක් දැයි දැන ගැනීමට, එයට දැනටමත් පිළිතුරු ලැබී ඇත.
නමුත් එහි අන්තර්ගතය මත පදනම්ව දැන ගැනීම සඳහා එහි නූලක් හෝ අංකයක් තිබේ නම්, මම මෙය භාවිතා කරමි:

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

සහ සමහර උදාහරණ සඳහා:

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