मैं String.StartsWithजावास्क्रिप्ट में C # के समकक्ष कैसे लिखूंगा ?
var haystack = 'hello world';
var needle = 'he';
haystack.startsWith(needle) == true
नोट: यह एक पुराना प्रश्न है, और जैसा कि टिप्पणियों में बताया गया है कि ECMAScript 2015 (ES6) ने .startsWithविधि पेश की । हालाँकि, इस अद्यतन को लिखने के समय (2015) ब्राउज़र समर्थन पूर्ण से बहुत दूर है ।
जवाबों:
आप ECMAScript 6 की String.prototype.startsWith()विधि का उपयोग कर सकते हैं , लेकिन यह अभी तक सभी ब्राउज़रों में समर्थित नहीं है । आप इसे समर्थन न करने वाले ब्राउज़रों पर जोड़ने के लिए एक शिम / पॉलीफ़िल का उपयोग करना चाहेंगे। एक कार्यान्वयन बनाना जो कल्पना में रखे गए सभी विवरणों का अनुपालन करता है, थोड़ा जटिल है। यदि आप एक वफादार शिम चाहते हैं, तो उपयोग करें:
String.prototype.startsWithशिम , याString.prototype.startsWith।एक बार जब आपने विधि को शर्मिंदा कर दिया (या यदि आप केवल ब्राउज़र और जावास्क्रिप्ट इंजन का समर्थन कर रहे हैं जो पहले से ही है), तो आप इसे इस तरह से उपयोग कर सकते हैं:
"Hello World!".startsWith("He"); // true
var haystack = "Hello world";
var prefix = 'orl';
haystack.startsWith(prefix); // falseइसके साथ एक और विकल्प .lastIndexOf:
haystack.lastIndexOf(needle, 0) === 0इंडेक्स से शुरू haystackहोने की घटना के लिए यह पीछे की ओर दिखता है । दूसरे शब्दों में, यह केवल तभी जाँच करता है जब इसके साथ शुरू होता है ।needle0haystackhaystackneedle
सिद्धांत रूप में, इसके कुछ अन्य दृष्टिकोणों पर प्रदर्शन लाभ होना चाहिए:
haystack।"aba".lastIndexOf ("a")2 है जैसा कि आप बताते हैं, लेकिन "aba".lastIndexOf ("a", 0)0 है, जो सही है
data.substring(0, input.length) === input.lastIndexOf(input, 0)पहले N वर्णों की तुलना करता है, जबकि .substring(0, input.length) === inputN की गणना करता है, डेटा को N लंबाई तक ले जाता है, और फिर उन N वर्णों की तुलना करता है। जब तक कोड अनुकूलन नहीं होता है, यह दूसरा संस्करण दूसरे की तुलना में तेज़ नहीं हो सकता है। हालांकि मुझे गलत मत समझो, मैं कभी भी अपने आप को आपके द्वारा सुझाए गए से बेहतर नहीं पाऊंगा। :)
lastIndexOfइंडेक्स 0 पर शुरू हुआ है, अंत नहीं। शुरू में यह मुझे बहुत परेशान करता था। फिर भी, यह जांचना कि एक स्ट्रिंग क्या शुरू होती है, यह इतना सामान्य कार्य है कि जावास्क्रिप्ट को वास्तव में इसके लिए एक उचित एपीआई होना चाहिए, न कि सभी मुहावरे और विकल्प जो आप इस पृष्ठ पर देखते हैं, हालांकि वे बहुत ही चतुर हैं।
हेल्पर फंक्शन के बिना, बस रेगेक्स .testविधि का उपयोग कर :
/^He/.test('Hello world')हार्डकोड के बजाय एक डायनामिक स्ट्रिंग के साथ ऐसा करने के लिए (यह मानते हुए कि स्ट्रिंग में कोई रेगेक्स कंट्रोल वर्ण नहीं होगा):
new RegExp('^' + needle).test(haystack)आपको यह देखना चाहिए कि क्या जावास्क्रिप्ट में RegExp.escape फ़ंक्शन है? यदि संभावना मौजूद है कि regexp नियंत्रण वर्ण स्ट्रिंग में दिखाई देते हैं।
/^he/i
सबसे अच्छा उपाय:
function startsWith(str, word) {
return str.lastIndexOf(word, 0) === 0;
}और यहाँ है endsWith अगर आपको लगता है कि बहुत जरूरत है:
function endsWith(str, word) {
return str.indexOf(word, str.length - word.length) !== -1;
}उन लोगों के लिए जो इसे स्ट्रिंग में प्रोटोटाइप करना पसंद करते हैं:
String.prototype.startsWith || (String.prototype.startsWith = function(word) {
return this.lastIndexOf(word, 0) === 0;
});
String.prototype.endsWith || (String.prototype.endsWith = function(word) {
return this.indexOf(word, this.length - word.length) !== -1;
});उपयोग:
"abc".startsWith("ab")
true
"c".ensdWith("c")
trueविधि के साथ:
startsWith("aaa", "a")
true
startsWith("aaa", "ab")
false
startsWith("abc", "abc")
true
startsWith("abc", "c")
false
startsWith("abc", "a")
true
startsWith("abc", "ba")
false
startsWith("abc", "ab")
trueमैं बस इस बारे में अपनी राय जोड़ना चाहता था।
मुझे लगता है कि हम इस तरह का उपयोग कर सकते हैं:
var haystack = 'hello world';
var needle = 'he';
if (haystack.indexOf(needle) == 0) {
// Code if string starts with this substring
}indexOfजब यह पहली घटना को पाएगा तो पूरी स्ट्रिंग को खोजना बंद कर देगा। मैंने इसकी जाँच की है।
यहाँ CMS के समाधान में मामूली सुधार किया गया है:
if(!String.prototype.startsWith){
String.prototype.startsWith = function (str) {
return !this.indexOf(str);
}
}
"Hello World!".startsWith("He"); // true
var data = "Hello world";
var input = 'He';
data.startsWith(input); // trueयह जाँच करना कि भविष्य का ब्राउज़र पहले से मौजूद है या नहीं, भविष्य का ब्राउज़र इसे देशी कोड में लागू करता है या यदि इसे किसी अन्य लाइब्रेरी द्वारा कार्यान्वित किया जाता है। उदाहरण के लिए, प्रोटोटाइप लाइब्रेरी इस फ़ंक्शन को पहले से लागू करता है।
उपयोग करना !थोड़ा तेज और अधिक संक्षिप्त है, === 0हालांकि पठनीय नहीं है।
String.prototypeएक बुरा विचार है क्योंकि यह कल्पना के लिए अनुपालन करने के करीब कहीं भी नहीं आता है String.prototype.startsWith। कोई भी कोड जो ES6 विधि का उपयोग करने की कोशिश करता है यदि आप ऐसा कर रहे हैं तो असफल होने के लिए उत्तरदायी है; यह देखने के लिए अच्छी तरह से लग सकता है कि क्या विधि पहले से ही परिभाषित है, यह देखें कि यह (बुरी तरह से, आपके द्वारा) है और एक कल्पना-अनुरूप शिम में नहीं जोड़ें, बाद में गलत व्यवहार के लिए अग्रणी है।
इसके अलावा underscore.string.js देखें । यह एक startsWithविधि सहित उपयोगी स्ट्रिंग परीक्षण और हेरफेर विधियों का एक गुच्छा के साथ आता है । डॉक्स से:
के साथ शुरू करो
_.startsWith(string, starts)यह विधि जांचती है कि क्या इसके
stringसाथ शुरू होता हैstarts।_("image.gif").startsWith("image") => true
_.string.startsWith
मैंने हाल ही में खुद से एक ही सवाल पूछा था।
कई संभावित समाधान हैं, यहां 3 वैध हैं:
s.indexOf(starter) === 0s.substr(0,starter.length) === starters.lastIndexOf(starter, 0) === 0(मार्क बायर्स का जवाब देखने के बाद जोड़ा गया )एक लूप का उपयोग करना:
function startsWith(s,starter) {
for (var i = 0,cur_c; i < starter.length; i++) {
cur_c = starter[i];
if (s[i] !== starter[i]) {
return false;
}
}
return true;
}मैं पिछले समाधान में नहीं आया हूं जो लूप का उपयोग करता है।
आश्चर्यजनक रूप से यह समाधान पहले 3 को एक महत्वपूर्ण मार्जिन से बेहतर बनाता है।
यहाँ jsperf परीक्षण है जो मैंने इस निष्कर्ष पर पहुंचने के लिए किया था: http://jsperf.com/startswith2/2
शांति
पीएस: पारिस्थितिकी 6 (सद्भाव) startsWithतार के लिए एक मूल विधि का परिचय देता है ।
जरा सोचिए कि अगर शुरुआती संस्करण में ही उन्हें इस बहुत जरूरी विधि को शामिल करने के बारे में सोचा होता तो कितना समय बच जाता।
अपडेट करें
जैसा कि स्टीव ने बताया (इस उत्तर पर पहली टिप्पणी), उपरोक्त कस्टम फ़ंक्शन एक त्रुटि फेंक देगा यदि दिए गए उपसर्ग पूरे स्ट्रिंग से कम है। उन्होंने तय किया है कि और एक लूप ऑप्टिमाइज़ेशन जोड़ा गया है जिसे http://jsperf.com/startswith2/4 पर देखा जा सकता है ।
ध्यान दें कि 2 लूप ऑप्टिमाइज़ेशन हैं, जिनमें स्टीव शामिल थे, दोनों में से पहले ने बेहतर प्रदर्शन दिखाया, इस प्रकार मैं उस कोड को नीचे पोस्ट करूंगा:
function startsWith2(str, prefix) {
if (str.length < prefix.length)
return false;
for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
continue;
return i < 0;
}चूंकि यह इतना लोकप्रिय है, मुझे लगता है कि यह इंगित करने के लायक है कि ECMA 6 में इस पद्धति के लिए एक कार्यान्वयन है और इसके लिए तैयारी में भविष्य की समस्याओं और आँसू को रोकने के लिए 'आधिकारिक' पॉलीफ़िल का उपयोग करना चाहिए।
सौभाग्य से मोज़िला के विशेषज्ञ हमें एक प्रदान करते हैं:
https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
if (!String.prototype.startsWith) {
String.prototype.startsWith = function(searchString, position) {
position = position || 0;
return this.indexOf(searchString, position) === position;
};
}कृपया ध्यान दें कि ECMA 6 के लिए संक्रमण पर इनायत से नजरअंदाज करने का यह फायदा है।
सबसे अच्छा प्रदर्शन समाधान पुस्तकालय कॉल का उपयोग करना बंद करना है और बस यह पहचानना है कि आप दो सरणियों के साथ काम कर रहे हैं। हाथ से लुढ़का हुआ कार्यान्वयन दोनों छोटे और हर दूसरे समाधान की तुलना में तेज है जो मैंने यहां देखा है।
function startsWith2(str, prefix) {
if (str.length < prefix.length)
return false;
for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
continue;
return i < 0;
}प्रदर्शन तुलना (सफलता और असफलता) के लिए, http://jsperf.com/startswith2/4 देखें । (यह सुनिश्चित करें कि आप बाद के संस्करणों की जाँच कर सकते हैं, जिनमें खदान हो सकती है।)
मैंने अभी इस स्ट्रिंग लाइब्रेरी के बारे में सीखा है:
Js फ़ाइल शामिल करें और फिर Sइस तरह चर का उपयोग करें:
S('hi there').endsWith('hi there')इसे स्थापित करके NodeJS में भी इसका उपयोग किया जा सकता है:
npm install stringफिर इसे Sचर के रूप में आवश्यकता होती है :
var S = require('string');वेब पेज में वैकल्पिक स्ट्रिंग लाइब्रेरीज़ के लिंक भी हैं, अगर यह आपके फैंस को नहीं भाता है।
मुझे मूल रूप से यह पता लगाने के लिए एक तेज़ तरीके की ज़रूरत थी कि क्या एक लंबी सुई एक लंबी बाधा के भीतर है और वे पिछले पात्रों को छोड़कर बहुत समान हैं।
यहाँ कोड मैंने लिखा है जो प्रत्येक फंक्शन (स्पाइस, सबस्ट्रिंग, स्टार्टविथ इत्यादि) के लिए होता है, दोनों का परीक्षण करता है जब वे nestedString१.०००.०००१ वर्णों के हेस्टैक स्ट्रिंग ( ) और १.००० / ०० के एक झूठा या सच्ची सुई स्ट्रिंग के खिलाफ गलत और सही लौटाते हैं। वर्ण ( testParentStringFalseऔर testParentStringTrue, क्रमशः):
// nestedString is made of 1.000.001 '1' repeated characters.
var nestedString = '...'
// testParentStringFalse is made of 1.000.000 characters,
// all characters are repeated '1', but the last one is '2',
// so for this string the test should return false.
var testParentStringFalse = '...'
// testParentStringTrue is made of 1.000.000 '1' repeated characters,
// so for this string the test should return true.
var testParentStringTrue = '...'
// You can make these very long strings by running the following bash command
// and edit each one as needed in your editor
// (NOTE: on OS X, `pbcopy` copies the string to the clipboard buffer,
// on Linux, you would probably need to replace it with `xclip`):
//
// printf '1%.0s' {1..1000000} | pbcopy
//
function testString() {
let dateStart
let dateEnd
let avg
let count = 100000
const falseResults = []
const trueResults = []
/* slice */
console.log('========> slice')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.slice(0, testParentStringFalse.length) === testParentStringFalse
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
falseResults[falseResults.length] = {
label: 'slice',
avg
}
console.log(`testString() slice = false`, res, 'avg: ' + avg + 'ms')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.slice(0, testParentStringTrue.length) === testParentStringTrue
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
trueResults[trueResults.length] = {
label: 'slice',
avg
}
console.log(`testString() slice = true`, res, 'avg: ' + avg + 'ms')
console.log('<======== slice')
console.log('')
/* slice END */
/* lastIndexOf */
console.log('========> lastIndexOf')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.lastIndexOf(testParentStringFalse, 0) === 0
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
falseResults[falseResults.length] = {
label: 'lastIndexOf',
avg
}
console.log(`testString() lastIndexOf = false`, res, 'avg: ' + avg + 'ms')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.lastIndexOf(testParentStringTrue, 0) === 0
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
trueResults[trueResults.length] = {
label: 'lastIndexOf',
avg
}
console.log(`testString() lastIndexOf = true`, res, 'avg: ' + avg + 'ms')
console.log('<======== lastIndexOf')
console.log('')
/* lastIndexOf END */
/* indexOf */
console.log('========> indexOf')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.indexOf(testParentStringFalse) === 0
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
falseResults[falseResults.length] = {
label: 'indexOf',
avg
}
console.log(`testString() indexOf = false`, res, 'avg: ' + avg + 'ms')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.indexOf(testParentStringTrue) === 0
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
trueResults[trueResults.length] = {
label: 'indexOf',
avg
}
console.log(`testString() indexOf = true`, res, 'avg: ' + avg + 'ms')
console.log('<======== indexOf')
console.log('')
/* indexOf END */
/* substring */
console.log('========> substring')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.substring(0, testParentStringFalse.length) === testParentStringFalse
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
falseResults[falseResults.length] = {
label: 'substring',
avg
}
console.log(`testString() substring = false`, res, 'avg: ' + avg + 'ms')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.substring(0, testParentStringTrue.length) === testParentStringTrue
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
trueResults[trueResults.length] = {
label: 'substring',
avg
}
console.log(`testString() substring = true`, res, 'avg: ' + avg + 'ms')
console.log('<======== substring')
console.log('')
/* substring END */
/* startsWith */
console.log('========> startsWith')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.startsWith(testParentStringFalse)
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
falseResults[falseResults.length] = {
label: 'startsWith',
avg
}
console.log(`testString() startsWith = false`, res, 'avg: ' + avg + 'ms')
dateStart = +new Date()
var res
for (let j = 0; j < count; j++) {
res = nestedString.startsWith(testParentStringTrue)
}
dateEnd = +new Date()
avg = (dateEnd - dateStart)/count
trueResults[trueResults.length] = {
label: 'startsWith',
avg
}
console.log(`testString() startsWith = true`, res, 'avg: ' + avg + 'ms')
console.log('<======== startsWith')
console.log('')
/* startsWith END */
falseResults.sort((a, b) => a.avg - b.avg)
trueResults.sort((a, b) => a.avg - b.avg)
console.log('false results from fastest to slowest avg:', falseResults)
console.log('true results from fastest to slowest avg:', trueResults)
}
मैंने इस बेंचमार्क टेस्ट को क्रोम 75 , फ़ायरफ़ॉक्स 67 , सफारी 12 और ओपेरा 62 पर चलाया ।
मैंने एज और IE को शामिल नहीं किया है क्योंकि मेरे पास इस मशीन पर नहीं है, लेकिन अगर आप में से कोई भी एज के खिलाफ स्क्रिप्ट चलाना चाहता है और कम से कम IE 9 और यहाँ आउटपुट को साझा करता है तो मैं परिणाम देखने के लिए बहुत उत्सुक होगा।
बस याद रखें कि आपको 3 लंबे तारों को फिर से बनाने और एक फ़ाइल में स्क्रिप्ट को सहेजने की ज़रूरत है जिसे आप तब अपने ब्राउज़र में खोलते हैं, जैसा कि ब्राउज़र के कंसोल पर कॉपी / पेस्ट होता है, इसे ब्लॉक कर देगा क्योंकि प्रत्येक स्ट्रिंग की लंबाई> = = 1.000.000 है)।
यहाँ आउटपुट हैं:
क्रोम 75 ( substringजीत):
false results from fastest to slowest avg:
1) {"label":"substring","avg":0.08271}
2) {"label":"slice","avg":0.08615}
3) {"label":"lastIndexOf","avg":0.77025}
4) {"label":"indexOf","avg":1.64375}
5) {"label":"startsWith","avg":3.5454}
true results from fastest to slowest avg:
1) {"label":"substring","avg":0.08213}
2) {"label":"slice","avg":0.08342}
3) {"label":"lastIndexOf","avg":0.7831}
4) {"label":"indexOf","avg":0.88988}
5) {"label":"startsWith","avg":3.55448}फ़ायरफ़ॉक्स 67 ( indexOfजीत):
false results from fastest to slowest avg
1) {"label":"indexOf","avg":0.1807}
2) {"label":"startsWith","avg":0.74621}
3) {"label":"substring","avg":0.74898}
4) {"label":"slice","avg":0.78584}
5) {"label":"lastIndexOf","avg":0.79668}
true results from fastest to slowest avg:
1) {"label":"indexOf","avg":0.09528}
2) {"label":"substring","avg":0.75468}
3) {"label":"startsWith","avg":0.76717}
4) {"label":"slice","avg":0.77222}
5) {"label":"lastIndexOf","avg":0.80527}सफारी 12 ( sliceझूठे परिणामों के startsWithलिए जीतता है, सच्चे परिणामों के लिए जीतता है, सफारी भी पूरे परीक्षण को निष्पादित करने के लिए कुल समय के मामले में सबसे तेज है:
false results from fastest to slowest avg:
1) "{\"label\":\"slice\",\"avg\":0.0362}"
2) "{\"label\":\"startsWith\",\"avg\":0.1141}"
3) "{\"label\":\"lastIndexOf\",\"avg\":0.11512}"
4) "{\"label\":\"substring\",\"avg\":0.14751}"
5) "{\"label\":\"indexOf\",\"avg\":0.23109}"
true results from fastest to slowest avg:
1) "{\"label\":\"startsWith\",\"avg\":0.11207}"
2) "{\"label\":\"lastIndexOf\",\"avg\":0.12196}"
3) "{\"label\":\"substring\",\"avg\":0.12495}"
4) "{\"label\":\"indexOf\",\"avg\":0.33667}"
5) "{\"label\":\"slice\",\"avg\":0.49923}"ओपेरा 62 ( substringजीतता है। परिणाम क्रोम के समान हैं और मुझे आश्चर्य नहीं है क्योंकि ओपेरा क्रोमियम और ब्लिंक पर आधारित है):
false results from fastest to slowest avg:
{"label":"substring","avg":0.09321}
{"label":"slice","avg":0.09463}
{"label":"lastIndexOf","avg":0.95347}
{"label":"indexOf","avg":1.6337}
{"label":"startsWith","avg":3.61454}
true results from fastest to slowest avg:
1) {"label":"substring","avg":0.08855}
2) {"label":"slice","avg":0.12227}
3) {"label":"indexOf","avg":0.79914}
4) {"label":"lastIndexOf","avg":1.05086}
5) {"label":"startsWith","avg":3.70808}यह पता चलता है कि हर ब्राउज़र का अपना कार्यान्वयन विवरण है (ओपेरा के अलावा, जो क्रोम के क्रोमियम और ब्लिंक पर आधारित है)।
बेशक, अलग-अलग उपयोग के मामलों के साथ आगे का परीक्षण किया जा सकता है और किया जाना चाहिए (जैसे कि जब सुई वास्तव में हिस्टैक की तुलना में कम होती है, जब हाइस्टैक सुई से छोटा होता है, आदि ...), लेकिन मेरे मामले में मुझे बहुत लंबे तार की तुलना करने की आवश्यकता थी और इसे यहां साझा करना चाहता था।
यहां दिए गए जवाबों के आधार पर, यह वह संस्करण है जिसका मैं अब उपयोग कर रहा हूं, क्योंकि यह JSPerf परीक्षण के आधार पर सबसे अच्छा प्रदर्शन देने के लिए लगता है (और कार्यात्मक रूप से जहां तक मैं बता सकता हूं) पूरा हो गया है।
if(typeof String.prototype.startsWith != 'function'){
String.prototype.startsWith = function(str){
if(str == null) return false;
var i = str.length;
if(this.length < i) return false;
for(--i; (i >= 0) && (this[i] === str[i]); --i) continue;
return i < 0;
}
}यह यहाँ से startWith2 पर आधारित था: http://jsperf.com/startswith2/6 । मैंने एक छोटे से प्रदर्शन में सुधार के लिए एक छोटा सा ट्विस्ट जोड़ा और तब से तुलना स्ट्रिंग के अशक्त या अपरिभाषित होने के लिए एक चेक भी जोड़ा, और इसे सीएमएस के उत्तर में तकनीक का उपयोग करके स्ट्रिंग प्रोटोटाइप में जोड़ने के लिए बदल दिया।
ध्यान दें कि यह कार्यान्वयन "स्थिति" पैरामीटर का समर्थन नहीं करता है जो इस मोज़िला डेवलपर नेटवर्क पेज में उल्लिखित है , लेकिन यह वैसे भी ECMAScript प्रस्ताव का हिस्सा नहीं लगता है।
मैं जावास्क्रिप्ट के लिए निश्चित नहीं हूं लेकिन टाइपस्क्रिप्ट में मैंने कुछ ऐसा किया है
var str = "something";
(<String>str).startsWith("some");मुझे लगता है कि इसे js पर भी काम करना चाहिए। मुझे उम्मीद है यह मदद करेगा!
यदि आप साथ काम कर रहे हैं startsWith()और endsWith()फिर आपको प्रमुख स्थानों के बारे में सावधान रहना होगा। यहाँ एक पूर्ण उदाहरण है:
var str1 = " Your String Value Here.!! "; // Starts & ends with spaces
if (str1.startsWith("Your")) { } // returns FALSE due to the leading spaces…
if (str1.endsWith("Here.!!")) { } // returns FALSE due to trailing spaces…
var str2 = str1.trim(); // Removes all spaces (and other white-space) from start and end of `str1`.
if (str2.startsWith("Your")) { } // returns TRUE
if (str2.endsWith("Here.!!")) { } // returns TRUEstartsWith()और endsWith()कार्यों के साथ अग्रणी स्थानों से सावधान रहना होगा । और कुछ नहीं!
आप सरणी के सभी सदस्यों को भी वापस कर सकते हैं, जो एक स्ट्रिंग के साथ शुरू होता है, सरणी प्रोटोटाइप के लिए अपना स्वयं का प्रोटोटाइप / एक्सटेंशन बनाकर, उर्फ
Array.prototype.mySearch = function (target) {
if (typeof String.prototype.startsWith != 'function') {
String.prototype.startsWith = function (str){
return this.slice(0, str.length) == str;
};
}
var retValues = [];
for (var i = 0; i < this.length; i++) {
if (this[i].startsWith(target)) { retValues.push(this[i]); }
}
return retValues;
};और इसका उपयोग करने के लिए:
var myArray = ['Hello', 'Helium', 'Hideout', 'Hamster'];
var myResult = myArray.mySearch('Hel');
// result -> Hello, Helium