“ස්ටාර්ට්ස් විත්” නූලක් වෙනත් නූලක් දැයි පරීක්ෂා කරන්නේ කෙසේද?

String.StartsWithජාවාස්ක්‍රිප්ට් හි සී # ට සමාන මා ලියන්නේ කෙසේද ?

var haystack = 'hello world';
var needle = 'he';

haystack.startsWith(needle) == true

සටහන: මෙය පැරණි ප්‍රශ්නයක් වන අතර, අදහස් දැක්වීමේදී පෙන්වා ඇති පරිදි ECMAScript 2015 (ES6) .startsWithක්‍රමය හඳුන්වා දුන්නේය . කෙසේ වෙතත්, මෙම යාවත්කාලීනය ලියන අවස්ථාවේ (2015) බ්‍රව්සර් සහාය සම්පූර්ණ නොවේ .

ඔබට ECMAScript 6 හි String.prototype.startsWith()ක්‍රමය භාවිතා කළ හැකිය , නමුත් එය තවමත් සියලුම බ්‍රව්සර්වල සහය නොදක්වයි . ඔබට සහාය නොදක්වන බ්‍රව්සර් මත එය එක් කිරීමට ෂිම් / පොලිෆිල් භාවිතා කිරීමට ඔබට අවශ්‍ය වනු ඇත. පිරිවිතරයේ දක්වා ඇති සියලුම විස්තර වලට අනුකූල වන පරිදි ක්‍රියාත්මක කිරීමක් නිර්මාණය කිරීම ටිකක් සංකීර්ණයි. ඔබට විශ්වාසවන්ත දිලිසීමක් අවශ්‍ය නම්, මේ දෙකම භාවිතා කරන්න:

• මතියස් බයිනන්ස්ගේ String.prototype.startsWithෂිම් , හෝ
• මෙම es6-සිම් ඇතුලු, හැකි ලෙස ES6 පිරිවිතර බොහෝ ලෙස shims, 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ක ඇතිවීමට needleදර්ශකය සිට ආරම්භ 0වන haystack. වෙනත් වචන වලින් කිවහොත්, එය පරික්ෂා කරන්නේ haystackආරම්භ වන්නේ නම් පමණි needle.

ප්‍රතිපත්තිමය වශයෙන්, මෙය වෙනත් ප්‍රවේශයන්ට වඩා කාර්ය සාධන වාසි තිබිය යුතුය:

• එය සමස්තයක්ම සොයන්නේ නැත haystack.
• එය නව තාවකාලික නූලක් සාදන්නේ නැති අතර වහාම එය ඉවතලන්න.

data.substring(0, input.length) === input

සහායක ශ්‍රිතයක් නොමැතිව, රීජෙක්ස් .testක්‍රමය භාවිතා කිරීම:

/^He/.test('Hello world')

දෘ c කේතකරණයකට වඩා ගතික නූලකින් මෙය සිදු කිරීම සඳහා (නූලෙහි කිසිදු රීජෙක්ස් පාලක අක්ෂර අඩංගු නොවන බව උපකල්පනය කරයි):

new RegExp('^' + needle).test(haystack)

ඔබ පරීක්ෂා කර බැලිය යුතුය ජාවාස්ක්‍රිප්ට් හි RegExp.escape ශ්‍රිතයක් තිබේද? රීජෙක්ස් පාලක අක්ෂර නූලෙහි දිස්වීමේ හැකියාව තිබේ නම්.

හොඳම විසඳුම:

function startsWith(str, word) {
    return str.lastIndexOf(word, 0) === 0;
}

ඔබටත් එය අවශ්‍ය නම් මෙහි කෙළවර වේ:

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
}

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කියවිය නොහැකි තරම් වේගවත් හා සංක්ෂිප්ත ය .

ද පරීක්ෂා underscore.string.js . එය startsWithක්‍රමයක් ඇතුළුව ප්‍රයෝජනවත් නූල් පරීක්ෂණ සහ හැසිරවීමේ ක්‍රම රාශියක් සමඟ පැමිණේ . ලියකියවිලි වලින්:

ආරම්භය සමඟ _.startsWith(string, starts)

මෙම ක්‍රමය stringආරම්භ වන්නේ දැයි පරීක්ෂා කරයි starts.

_("image.gif").startsWith("image")
=> true

මම මෑතකදී එම ප්‍රශ්නයම මගෙන්ම ඇසුවෙමි.
හැකි විසඳුම් කිහිපයක් ඇත, මෙහි වලංගු විසඳුම් 3 ක් ඇත:

• s.indexOf(starter) === 0
• s.substr(0,starter.length) === starter
• s.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

සාම

ps: ecmascript 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 හි මෙම ක්‍රමය ක්‍රියාත්මක කිරීමක් ඇති බව පෙන්වා දීම වටී යැයි මම සිතමි. ඒ සඳහා සූදානම් වීමේ දී අනාගත ගැටළු සහ කඳුළු වැළැක්වීම සඳහා 'නිල' පොලිෆිල් භාවිතා කළ යුතුය.

වාසනාවකට මෙන් මොසිල්ලා හි විශේෂ experts යින් අපට එකක් සපයයි:

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 බලන්න . (මගේ තුරුම්පුව විය හැකි පසු සංස්කරණ සඳහා ඔබ පරීක්ෂා කර බැලීමට වග බලා ගන්න.)

මම මේ සංගීත පුස්තකාලය ගැන ඉගෙන ගත්තා:

http://stringjs.com/

Js ගොනුව ඇතුළත් කර ඉන්පසු Sවිචල්‍යය භාවිතා කරන්න :

S('hi there').endsWith('hi there')

එය ස්ථාපනය කිරීමෙන් NodeJS හි ද භාවිතා කළ හැකිය:

npm install string

ඉන්පසු එය Sවිචල්‍යය ලෙස අවශ්‍ය වේ:

var S = require('string');

මෙය ඔබේ මනස්කාන්තය නොගන්නේ නම්, වෙබ් පිටුවට විකල්ප සංගීත පුස්තකාල වෙත සබැඳි ද ඇත.

2019. ප්‍රශ්නය ටිකක් පරණයි, නමුත් මෙහි දී ඇති සියලුම පිළිතුරු සහ ජිම් බක් විසින් බෙදාගත් jsperf මත පදනම්ව මා විසින් සාදන ලද මිණුම් සලකුණු කිහිපයක් ඔබට පෙන්වීමට මෙම පිළිතුර ලිවීමට මට අවශ්‍ය විය.

දිගු ඉඳිකටුවක් දිගු පිදුරු මඩුවක තිබේදැයි සොයා බැලීමට මට මූලික වශයෙන් වේගවත් ක්‍රමයක් අවශ්‍ය වූ අතර අවසාන අක්ෂර හැර ඒවා බොහෝ සමාන වේ.

nestedStringඅක්ෂර 1.000.0001 කින් යුත් පිදුරු දණ්ඩකට ( ) සහ ව්‍යාජ හෝ සත්‍ය ඉඳිකටු නූල 1.000.000 ට එරෙහිව ව්‍යාජ හා සත්‍ය ලෙස නැවත පැමිණෙන විට එක් එක් ශ්‍රිතය (භේදය, උපස්ථරය, ආරම්භය, ආදිය) පරීක්ෂා කරන කේතය මෙන්න. අක්ෂර ( 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 .

මම මෙම යන්ත්‍රය තුළ නොමැති නිසා මම එඩ්ජ් සහ අයිඊ ඇතුළත් කර නැත, නමුත් ඔබෙන් කෙනෙකුට එඩ්ජ්ට හා අවම වශයෙන් අයිඊ 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 ව්‍යාජ ප්‍රති results startsWithල සඳහා ජයග්‍රහණ, සත්‍ය ප්‍රති results ල සඳහා ජයග්‍රහණ, සහ සම්පූර්ණ පරීක්ෂණය ක්‍රියාත්මක කිරීමට ගතවන කාලය අනුව වේගවත්ම වේ සෆාරි):

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 ජය. ප්‍රති Results ල ක්‍රෝම් වලට සමාන වන අතර ඔපෙරා ක්‍රෝමියම් සහ බ්ලින්ක් මත පදනම් වී ඇති බැවින් මම පුදුම නොවෙමි):

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}

සෑම බ්‍රව්සරයකටම තමන්ගේම ක්‍රියාත්මක කිරීමේ තොරතුරු ඇති බව පෙනේ (ඔපෙරා හැර, එය ක්‍රෝම් හි ක්‍රෝමියම් සහ බ්ලින්ක් මත පදනම් වේ).

ඇත්ත වශයෙන්ම, විවිධ භාවිත අවස්ථා සමඟ තවදුරටත් පරීක්‍ෂා කළ හැකි හා කළ යුතු ය (උදා: පිදුරු මඩුව හා සසඳන විට ඉඳිකටුවක් කෙටි වන විට, පිදුරු මඩුව ඉඳිකටුවට වඩා කෙටි වන විට ...), නමුත් මගේ නඩුවේදී මට ඉතා දිගු නූල් සංසන්දනය කිරීමට අවශ්‍ය විය. එය මෙහි බෙදා ගැනීමට අවශ්‍ය විය.

var str = 'hol';
var data = 'hola mundo';
if (data.length >= str.length && data.substring(0, str.length) == str)
    return true;
else
    return false;

මෙහි ඇති පිළිතුරු මත පදනම්ව, මෙය මම දැන් භාවිතා කරන අනුවාදය වන අතර, එය ජේඑස්පර්ෆ් පරීක්ෂාව මත පදනම්ව හොඳම කාර්ය සාධනය ලබා දෙන බව පෙනේ (එය මට කිව හැකි තාක් දුරට ක්‍රියාකාරීව සම්පූර්ණයි).

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

මෙය ආරම්භක විත් 2 මත පදනම් විය: http://jsperf.com/startswith2/6 . ඉතා කුඩා කාර්ය සාධනය වැඩි දියුණු කිරීම සඳහා මම කුඩා වෙනස් කිරීමක් එකතු කළ අතර, එතැන් සිට සංසන්දනාත්මක නූල අහෝසි වී හෝ නිර්වචනය කර නොමැතිදැයි පරීක්ෂා කර, CMS හි පිළිතුරෙහි ඇති තාක්‍ෂණය භාවිතා කරමින් එය නූල් මූලාකෘතියට එක් කිරීමට පරිවර්තනය කළෙමි.

මෙම ක්‍රියාත්මක කිරීම මෙම මොසිල්ලා සංවර්ධක ජාල පිටුවේ සඳහන් "පිහිටුම්" පරාමිතියට සහය නොදක්වන බව සලකන්න , නමුත් එය කෙසේ හෝ ECMAScript යෝජනාවේ කොටසක් ලෙස නොපෙනේ.

මට ජාවාස්ක්‍රිප්ට් ගැන විශ්වාස නැත, නමුත් යතුරු ලියනයෙහි මම එවැනි දෙයක් කළෙමි

var str = "something";
(<String>str).startsWith("some");

මම හිතන්නේ එය ජේඑස් මත ද ක්‍රියාත්මක විය යුතුයි. එය උපකාරී වේ යැයි මම බලාපොරොත්තු වෙමි!

ඔබ වැඩ කරන්නේ නම් 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 TRUE

ඔබේම මූලාකෘතියක් / දිගුවක් අරාව මූලාකෘතියට නිර්මාණය කිරීමෙන් ඔබට නූලකින් ආරම්භ වන අරාවෙහි සියලුම සාමාජිකයින්ට ආපසු යා හැකිය.

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