जवाबों:
आप 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] के खिलाफ शायद ही कभी इसका इस्तेमाल किया जाता है और इसकी सिफारिश की जाती है । यदि आप चाहें, तो इनसे कैसे निपटें, इसके अन्य उत्तर देखें।
new String('foo'), लेकिन इससे कोई फर्क नहीं पड़ता क्योंकि ऑब्जेक्ट-लिपटे स्ट्रिंग्स एक बेकार सुविधा है जिसका आपको उपयोग नहीं करना चाहिए। Google शैली मार्गदर्शिका उन्हें मना करती है , डगलस क्रॉकफ़ोर्ड उन्हें पदावनत करना चाहता है , और कोई भी पुस्तकालय उनका उपयोग नहीं करता है। बहाना वे मौजूद नहीं है, और typeofडर के बिना उपयोग करें ।
यह मेरे लिए काम करता है:
if (typeof myVar === 'string' || myVar instanceof String)
// it's a string
else
// it's something elseinstanceofयहां जांच व्यर्थ शोर है जब तक आप कुछ बहुत ही असामान्य कोडिंग प्रथाओं का पालन नहीं कर रहे हैं , और यह उत्तर यह बताने के लिए कुछ भी नहीं करता है कि यह क्या करता है या आप इसका उपयोग क्यों कर सकते हैं। एकमात्र कारण जिसकी आपको कभी आवश्यकता होगी यदि आप ऑब्जेक्ट-लिपटे स्ट्रिंग्स का उपयोग करते हैं, लेकिन ऑब्जेक्ट-लिपटे स्ट्रिंग्स एक बेकार विशेषता है जिसका कोई भी उपयोग नहीं करता है और Google और Crockford दोनों खराब अभ्यास के रूप में निंदा करते हैं ( google-styleguide.googlecode.com/svn) ट्रंक /… , crockford.com/javascript/recommend.html )।
typeofऔर instanceofअच्छी सलाह की तरह महसूस करता है यदि आपका कोड दूसरों द्वारा कहा जा सकता है। ' @ MarkAmery के postmessageकिनारे का मामला मायने रखता है यदि आप पूछ रहे हैं कि "मैं सिर्फ postmessaged क्या था ?" - लेकिन आप चाहते हैं कि इंटरफ़ेस को संभाला जाए और प्रचारित न होने दिया जाए। अन्य जगहों पर, गैर-डिप्रेस्ड कोडिंग विधियों को संभालना सही लगता है, भले ही कुछ जेएस सौंदर्यशास्त्री उन्हें अस्वीकार कर दें। स्ट्रिंग को स्वीकार करने के रूप में कभी भी अपने कोड पर टिप्पणी न करें, जब तक कि यह वास्तव में नहीं करता है!
चूंकि 580+ लोगों ने एक गलत जवाब के लिए वोट दिया है, और 800+ ने एक कामकाजी लेकिन शॉटगन शैली के जवाब के लिए वोट दिया है, मैंने सोचा कि यह मेरे जवाब को एक सरल रूप में फिर से लिखने के लायक हो सकता है जिसे हर कोई समझ सकता है।
function isString(x) {
return Object.prototype.toString.call(x) === "[object String]"
}या, इनलाइन (मेरे पास इसके लिए एक UltiSnip सेटअप है):
Object.prototype.toString.call(myVar) === "[object String]"FYI करें, पाब्लो सांता क्रूज़ का जवाब गलत है, क्योंकि typeof new String("string")हैobject
DRAX का उत्तर सटीक और कार्यात्मक है, और सही उत्तर होना चाहिए (क्योंकि पाब्लो सांता क्रूज़ सबसे निश्चित रूप से गलत है, और मैं लोकप्रिय वोट के खिलाफ बहस नहीं करूंगा।)
हालाँकि, यह उत्तर भी निश्चित रूप से सही है, और वास्तव में सबसे अच्छा उत्तर (छोड़कर, शायद, लॉश / अंडरस्कोर के उपयोग के सुझाव के लिए )। अस्वीकरण: मैंने लॉश 4 कोडबेस में योगदान दिया।
मेरा मूल उत्तर (जो स्पष्ट रूप से बहुत सिर पर उड़ गया) निम्न प्रकार है:
मैंने इसे अंडरस्कोर से हटा दिया। js:
['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'].forEach(
function(name) {
window['is' + name] = function(obj) {
return toString.call(obj) == '[object ' + name + ']';
};
});जो परिभाषित करेगा, वह है स्ट्रींग, इसनंबर, आदि।
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)कार्यों और async कार्यों के बीच में भी परिसीमन करने के लिए काम करता है:
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))global || windowwindow
myObject+"" === myObjectलिए जांच करूंगा कि क्या कोई वस्तु एक स्ट्रिंग है (या इससे भी बेहतर, मैं पहली बार एक व्यवहार चालित प्रकार की प्रणाली में जांच नहीं करूंगा)।
toStringमें Object.prototype। इसलिए, मेरा तर्क है कि toStringकिसी वस्तु के प्रकार की जांच करने के लिए भरोसा करना , सबसे अच्छा, एक बुरा अभ्यास है।
मैं jQuery या लॉश / अंडरस्कोर से अंतर्निहित कार्यों का उपयोग करने की सलाह देता हूं । वे उपयोग करने के लिए सरल और पढ़ने में आसान हैं।
या तो फ़ंक्शन DRAX उल्लेख किए गए मामले को संभाल लेगा ... अर्थात, वे दोनों जांचते हैं कि क्या (ए) चर एक स्ट्रिंग शाब्दिक है या (बी) यह स्ट्रिंग ऑब्जेक्ट का एक उदाहरण है। किसी भी स्थिति में, ये फ़ंक्शन एक स्ट्रिंग होने के रूप में मान की सही पहचान करते हैं।
लॉश / अंडरस्कोर। जेएस
if(_.isString(myVar))
//it's a string
else
//it's something elsejQuery
if($.type(myVar) === "string")
//it's a string
else
//it's something elseदेखें _.isString () के लिए lodash प्रलेखन अधिक जानकारी के लिए।
देखें $ .type () के लिए jQuery प्रलेखन अधिक जानकारी के लिए।
_.every()पहली बार में उपयोग करने के लिए थोड़ा भ्रामक है, और कुछ सरल के रूप _.isBoolean()में मेरी कंपनी में देवों को भ्रमित किया है। एक देव ने गलती से सोचा कि यह गलत होगा यदि मूल्य एक बूलियन था और गलत था। मेरे लिए जर्मन की तुलना में अंग्रेजी पढ़ना आसान है, क्योंकि मैं जर्मन नहीं जानता। जावास्क्रिप्ट सीखें और यह सब समझ में आएगा।
function isString (obj) {
return (Object.prototype.toString.call(obj) === '[object String]');
}मैंने देखा कि यहाँ:
http://perfectionkills.com/instanceof-considered-harmful-or-how-to-write-a-robust-isarray/
Object.prototype.toString.call(obj) === '[object String]'?
(x === y)इससे बेहतर पठनीयता है x === y?
सर्वोत्तम मार्ग:
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');इनमें से प्रत्येक का निर्माण इसके उपयुक्त वर्ग फ़ंक्शन द्वारा किया गया है, जैसे "नई वस्तु ()" आदि।
इसके अलावा, डक-टाइपिंग: "यदि यह बतख की तरह दिखता है, तो बतख की तरह चलता है, और बतख की तरह बदबू आती है - यह एक सरणी होना चाहिए" अर्थ, इसके गुणों की जांच करें।
उम्मीद है की यह मदद करेगा।
याद रखें, आप हमेशा दृष्टिकोणों के संयोजन का भी उपयोग कर सकते हैं। यहाँ एक का उपयोग करने का एक उदाहरण है टाइपोफ़ के साथ क्रियाओं के इनलाइन मानचित्र का :
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 ए .toString() method। आपने बस यह सुनिश्चित किया है कि संख्या का स्ट्रिंग-समरूप समान था, और फिर आपने सुनिश्चित किया कि आपने इसे पास कर दिया हैhttp फ़ंक्शन में पास किया है Number। दूसरे शब्दों में, हमने भी परवाह नहीं की इसकी कि इसका प्रकार क्या था।
आशा है कि आप के साथ काम करने के लिए और अधिक देता है :)
(o.constructor === Number || s.constructor === Boolean)) के साथ खेलना चाह सकते हैं । अनायास, parseIntऔर NaNनाजुक लेकिन शक्तिशाली उपकरण हैं। बस याद रखें, Not-a-Number Not-a-Number नहीं है, और अपरिभाषित को परिभाषित किया जा सकता है।
if(thing.call) { 'its a function'; }या if(thing.defineProperties) { 'its an object'; }। इनपुट के लिए धन्यवाद, axkibe!
मैं ईमानदारी से नहीं देख सकता कि कोई 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
}undefinedऔर null, और अभी भी रिक्त स्ट्रिंग (दोनों के लिए जवाब सही हो रही है ''और new String(''))।
(mystring || false) && mystring.constructor === String:। यदि यह एक फ़ंक्शन में उपयोग किया जाता है तो मुझे एक झूठी चीज़ का उपयोग करना चाहिए जो बूलियन को वापस करना होगा।
यह इस बात का एक बड़ा उदाहरण है कि प्रदर्शन क्यों मायने रखता है:
एक स्ट्रिंग के लिए परीक्षण के रूप में सरल कुछ करना महंगा हो सकता है अगर सही तरीके से नहीं किया गया हो।
उदाहरण के लिए, अगर मैं परीक्षण करना चाहता था कि यदि कोई स्ट्रिंग है तो परीक्षण करने के लिए, मैं इसे दो में से एक तरीके से कर सकता हूं:
1) const isString = str => (Object.prototype.toString.call(str) === '[object String]');
2) const isString = str => ((typeof str === 'string') || (str instanceof String));
ये दोनों बहुत सीधे आगे हैं, इसलिए संभवतः प्रदर्शन पर क्या प्रभाव पड़ सकता है? सामान्यतया, फ़ंक्शन कॉल महंगे हो सकते हैं, खासकर अगर आपको नहीं पता कि अंदर क्या हो रहा है। पहले उदाहरण में, ऑब्जेक्ट के इनस्ट्रिंग विधि के लिए एक फ़ंक्शन कॉल है। दूसरे उदाहरण में, कोई फ़ंक्शन कॉल नहीं है, क्योंकि टाइपोफ़ और इंस्टोफ़ ऑपरेटर हैं। फंक्शन कॉल की तुलना में ऑपरेटर्स काफी तेज होते हैं।
जब प्रदर्शन का परीक्षण किया जाता है, तो उदाहरण 1 उदाहरण 2 की तुलना में 79% धीमा है!
परीक्षण देखें: https://jsperf.com/isstringtype
typeof str === 'string' || str instanceof String(कोष्ठकों को छोड़ सकता हूं जो मैं if (..)मामलों में पसंद करता हूं ); इसकी परवाह किए बिना, # 2 में आदिम और वस्तु दोनों प्रकार की जाँच स्पष्ट और पर्याप्त है। इन चेकों को वैसे भी 'दुर्लभ' होना चाहिए।
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मुझे लगता है कि 90% मामलों में @customcommander समाधान पर्याप्त होना चाहिए:
typeof str === 'string'आपको सही सेवा करनी चाहिए (बस सामान्य रूप से कोई कारण नहीं है new String('something') से आपके कोड में )।
यदि आप को संभालने में रुचि रखते हैं String वस्तु को (उदाहरण के लिए आप किसी तृतीय पक्ष से कुछ संस्करण की अपेक्षा करते हैं) तो लॉश का उपयोग करते हुए @ ClearCloud8 के रूप में सुझाए गए एक स्पष्ट, सरल और सुरुचिपूर्ण समाधान की तरह लगता है।
लेकिन मैं उनके आकार के कारण लीकेज जैसे पुस्तकालयों से सावधान रहने का सुझाव दूंगा। करने के बजाय
import _ from 'lodash'
...
_.isString(myVar)जो पूरे विशाल लॉश ऑब्जेक्ट को लाता है, मैं कुछ सुझाव देना चाहूंगा:
import { isString as _isString } from 'lodash'
...
_isString(myVar)और सरल बंडलिंग के साथ आपको ठीक होना चाहिए (मैं यहां ग्राहक कोड का संदर्भ देता हूं)।
यदि आप नोड.जेएस पर्यावरण पर काम करते हैं, तो आप केवल अंतर्निहित फ़ंक्शन का उपयोग कर सकते हैं।
const util = require('util');
if (util.isString(myVar)) {}संपादित करें: जैसा कि @ जेहि ने उल्लेख किया है, यह v4 के बाद से हटा दिया गया है।
typeof value === 'string'इसके बजाय उपयोग करें ।"
x = new String('x'); x.isString(x);झूठा लौटता है । नहीं है util.types.isStringObject(), लेकिन वह रिटर्न के लिए झूठी x = 'x'प्रकार स्ट्रिंग। दो उपयोगिता कार्य जो पूरी तरह से कोई उपयोगिता प्रदान करते हैं ...
निम्न विधि जाँच करेगी कि क्या कोई चर एक स्ट्रिंग है ( चर जो मौजूद नहीं है सहित )।
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पहले से ही एक स्ट्रिंग है तो यदि कथन सफल है।
typeof।
typeofलेकिन अभी भी काफी तेजी से थोड़ा सा है toString। किसी भी तरह से, मुझे लगता है कि मैं सिर्फ जबरदस्ती के लिए वाक्यविन्यास पसंद करता हूं।
var s = new String('abc'); > s === s + '' > false
new Stringक्यूस के साथ काम नहीं करता है जो एक प्रकार का बनाता है object। w3schools.com/js/tryit.asp?filename=tryjs_string_object2
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))false।
मुझे यह सरल तकनीक स्ट्रिंग के लिए टाइप-चेक करने के लिए उपयोगी लगती है -
String(x) === x // true, if x is a string
// false in every other caseconst 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 caseconst 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 caseconst 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 caseNB, regexps, arrays और फ़ंक्शन को ऑब्जेक्ट भी माना जाता है।
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 caseconst 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 falsevar x = new String(x); String(x)===xझूठा लौटता है। लेकिन ({}).toString.call(x).search(/String/)>0हमेशा रेशेदार चीजों के लिए देता है
function isClass(x,re){return ({}).toString.call(x).search(re)>0;}; isClass("hello",/String/) या isClass(3,/Number/)याisClass(null,/Null/)
एक सरल समाधान होगा:
var x = "hello"
if(x === x.toString()){
// it's a string
}else{
// it isn't
}toString()कार्य होता है
.toStringकिसी भी मूल्य पर कॉल नहीं कर सकते ; अगर जाँच की जाने वाली x को शून्य या अपरिभाषित किया जाता है, तो आपका कोड अपवाद छोड़ दें
toString()विधि ओवरराइड हो सकती है और अपवाद को फेंक सकती है (कुछ विशिष्ट कार्यान्वयन के कारण), और आपका चेक निश्चित रूप से काम नहीं करेगा। मुख्य विचार यह है कि आपको उन तरीकों को नहीं बुलाना चाहिए जो आप प्राप्त करना चाहते हैं, जो इससे संबंधित नहीं हैं। मैं toStringविधि से संबंधित अनावश्यक ओवरहेड के बारे में भी बात नहीं कर रहा हूं । Downvoting।
एक टंकक सहायक:
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)
मैं यहां बाकी हिस्सों के लिए एक अलग मार्ग पर जा रहा हूं, जो यह बताने की कोशिश करता है कि क्या चर विशिष्ट है, या विशिष्ट सेट का सदस्य है, प्रकार का।
JS को ducktyping पर बनाया गया है; अगर कुछ स्ट्रिंग की तरह होता है, तो हम उसे स्ट्रिंग की तरह इस्तेमाल कर सकते हैं।
है 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ठीक ठीक कार्यों के माध्यम से चला सकते हैं।
यह यह लचीलापन है जो जेएस को अपनी शक्ति देता है, और स्ट्रिंग्स के लिए परीक्षण विशेष रूप से आपके कोड को कम अंतर बनाता है।
उपरोक्त का आउटपुट है:
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"तो, यह सब क्यों आप जानना चाहते हैं कि क्या कुछ स्ट्रिंग है।
यदि, मेरी तरह, आप Google से यहां पहुंचे और यह देखना चाहते हैं कि क्या कुछ स्ट्रिंग-जैसा था , तो यहां एक जवाब है।
यह बहुत महंगा नहीं है जब तक कि आप वास्तव में लंबे या गहरी नेस्टेड सरणियों के साथ काम नहीं कर रहे हों।
यह इसलिए है क्योंकि यह सब है अगर बयान, कोई फ़ंक्शन कॉल नहीं करता है .toString()।
यदि आप यह देखने की कोशिश कर रहे हैं कि क्या वस्तुओं के साथ एक चार सरणी है जिसमें केवल toString()'s या मल्टी-बाइट वर्ण हैं, जिस स्थिति में स्ट्रिंग बनाने के अलावा कोई अन्य तरीका नहीं है, और वर्णों को गिनने के लिए क्रमशः बाइट्स बनाते हैं।
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('');
}
}शामिल विकल्प हैं
.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});आउटपुट:
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);
}यह nullएस और 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मुझे यकीन नहीं है कि अगर आप यह जानना चाहते हैं कि stringक्या इसकी सामग्री की परवाह किए बिना एक प्रकार है , या क्या यह सामग्री एक संख्या या स्ट्रिंग है, भले ही इसके प्रकार की परवाह किए बिना।
तो यह जानने के लिए कि क्या इसका प्रकार एक स्ट्रिंग है, इसका उत्तर पहले ही दिया जा चुका है।
लेकिन इसकी सामग्री के आधार पर यह जानने के लिए कि क्या इसकी एक स्ट्रिंग या एक संख्या है, मैं इसका उपयोग करूंगा:
function isNumber(item) {
return (parseInt(item) + '') === item;
}और कुछ उदाहरणों के लिए:
isNumber(123); //true
isNumber('123'); //true
isNumber('123a');//false
isNumber(''); //false/^\d+$/.test('123')संभावित पार्सिंग मुद्दों की पेचीदगियों से बचने के लिए ऐसा