Bagaimana cara memeriksa apakah suatu string “Mulai dengan” string lain?

Bagaimana saya menulis yang setara dengan C # String.StartsWithdi JavaScript?

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

haystack.startsWith(needle) == true

Catatan: Ini adalah pertanyaan lama, dan sebagaimana ditunjukkan dalam komentar ECMAScript 2015 (ES6) memperkenalkan .startsWithmetode ini. Namun, pada saat penulisan pembaruan ini (2015) dukungan browser masih jauh dari selesai .

Anda dapat menggunakan String.prototype.startsWith()metode ECMAScript 6 , tetapi belum didukung di semua browser . Anda akan ingin menggunakan shim / polyfill untuk menambahkannya di browser yang tidak mendukungnya. Membuat implementasi yang sesuai dengan semua detail yang tercantum dalam spesifikasi agak rumit. Jika Anda menginginkan shim yang setia, gunakan:

• Matthias Bynens ini String.prototype.startsWithshim , atau
• The ES6-shim , yang shims sebanyak ES6 spesifikasi mungkin, termasuk String.prototype.startsWith.

Setelah Anda memangkas metode (atau jika Anda hanya mendukung browser dan mesin JavaScript yang sudah memilikinya), Anda dapat menggunakannya seperti ini:

"Hello World!".startsWith("He"); // true

var haystack = "Hello world";
var prefix = 'orl';
haystack.startsWith(prefix); // false

Alternatif lain dengan .lastIndexOf:

haystack.lastIndexOf(needle, 0) === 0

Hal ini terlihat mundur melalui haystackuntuk terjadinya needlemulai dari indeks 0dari haystack. Dengan kata lain, itu hanya memeriksa jika haystackdimulai dengan needle.

Pada prinsipnya, ini harus memiliki keunggulan kinerja dibandingkan beberapa pendekatan lain:

• Itu tidak mencari keseluruhan haystack.
• Itu tidak membuat string sementara baru dan kemudian segera membuangnya.

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

Tanpa fungsi pembantu, hanya menggunakan .testmetode regex :

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

Untuk melakukan ini dengan string dinamis daripada yang dikodekan (dengan asumsi bahwa string tidak akan mengandung karakter kontrol regexp):

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

Anda harus memeriksa Apakah ada fungsi RegExp.escape di Javascript? jika ada kemungkinan karakter kontrol regexp muncul di string.

Solusi terbaik:

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

Dan ini adalah akhir Dengan jika Anda membutuhkannya juga:

function endsWith(str, word) {
    return str.indexOf(word, str.length - word.length) !== -1;
}

Bagi mereka yang lebih suka prototipe ke dalam String:

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

Pemakaian:

"abc".startsWith("ab")
true
"c".ensdWith("c") 
true

Dengan metode:

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

Saya hanya ingin menambahkan pendapat saya tentang ini.

Saya pikir kita bisa menggunakan seperti ini:

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

if (haystack.indexOf(needle) == 0) {
  // Code if string starts with this substring
}

Berikut ini adalah sedikit peningkatan pada solusi 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

Memeriksa apakah fungsi sudah ada jika browser masa depan mengimplementasikannya dalam kode asli atau jika itu diterapkan oleh perpustakaan lain. Misalnya, Perpustakaan Prototipe sudah mengimplementasikan fungsi ini.

Penggunaannya !sedikit lebih cepat dan lebih ringkas daripada === 0meski tidak bisa dibaca.

Lihat juga underscore.string.js . Muncul dengan sekelompok metode pengujian dan manipulasi string yang berguna, termasuk startsWithmetode. Dari dokumen:

dimulai dengan _.startsWith(string, starts)

Metode ini memeriksa apakah stringdimulai dengan starts.

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

Baru-baru ini saya bertanya pada diri sendiri pertanyaan yang sama.
Ada beberapa solusi yang mungkin, berikut 3 yang valid:

• s.indexOf(starter) === 0
• s.substr(0,starter.length) === starter
• s.lastIndexOf(starter, 0) === 0(ditambahkan setelah melihat jawaban Mark Byers )

• menggunakan loop:

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

Saya belum menemukan solusi terakhir yang menggunakan loop.
Anehnya solusi ini mengungguli 3 yang pertama dengan selisih yang signifikan.
Berikut adalah tes jsperf yang saya lakukan untuk mencapai kesimpulan ini: http://jsperf.com/startswith2/2

Perdamaian

ps: ecmascript 6 (harmoni) memperkenalkan startsWithmetode asli untuk string.
Bayangkan berapa banyak waktu yang akan dihemat jika mereka berpikir untuk memasukkan metode yang sangat dibutuhkan ini dalam versi awal itu sendiri.

Memperbarui

Seperti yang ditunjukkan Steve (komentar pertama pada jawaban ini), fungsi khusus di atas akan menimbulkan kesalahan jika awalan yang diberikan lebih pendek dari seluruh string. Dia telah memperbaikinya dan menambahkan optimasi loop yang dapat dilihat di http://jsperf.com/startswith2/4 .

Perhatikan bahwa ada 2 optimisasi loop yang disertakan Steve, yang pertama dari keduanya menunjukkan kinerja yang lebih baik, jadi saya akan memposting kode di bawah ini:

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

Karena ini sangat populer, saya pikir perlu menunjukkan bahwa ada implementasi untuk metode ini dalam ECMA 6 dan dalam persiapan untuk itu orang harus menggunakan polyfill 'resmi' untuk mencegah masalah dan air mata di masa depan.

Untungnya para ahli di Mozilla memberi kami satu:

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

Harap dicatat bahwa ini memiliki keuntungan diabaikan dengan anggun pada transisi ke ECMA 6.

Solusi berkinerja terbaik adalah berhenti menggunakan panggilan perpustakaan dan hanya mengenali bahwa Anda bekerja dengan dua array. Implementasi linting tangan keduanya pendek dan juga lebih cepat daripada setiap solusi lain yang saya lihat di sini.

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

Untuk perbandingan kinerja (sukses dan gagal), lihat http://jsperf.com/startswith2/4 . (Pastikan Anda memeriksa versi selanjutnya yang mungkin memiliki versi palsu saya.)

Saya baru saja belajar tentang perpustakaan string ini:

http://stringjs.com/

Sertakan file js dan kemudian gunakan Svariabel seperti ini:

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

Itu juga dapat digunakan di NodeJS dengan menginstalnya:

npm install string

Kemudian membutuhkannya sebagai Svariabel:

var S = require('string');

Halaman web juga memiliki tautan ke pustaka string alternatif, jika ini tidak sesuai keinginan Anda.

2019. Pertanyaannya agak lama, tetapi saya ingin menulis jawaban ini untuk menunjukkan kepada Anda beberapa tolok ukur yang saya buat berdasarkan semua jawaban yang diberikan di sini dan jsperf yang dibagikan oleh Jim Buck.

Saya pada dasarnya membutuhkan cara cepat untuk menemukan apakah jarum panjang berada dalam tumpukan jerami panjang dan mereka sangat mirip kecuali untuk karakter terakhir.

Berikut kode yang saya tulis yang untuk setiap fungsi (sambatan, substring, beginWith, dll.) Menguji keduanya ketika mereka mengembalikan false dan true terhadap string tumpukan jerami ( nestedString) dari 1.000.0001 karakter dan string jarum palsu atau benar 1.000.000 karakter ( testParentStringFalsedan testParentStringTrue, masing-masing):

// 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)
}

Saya menjalankan tes benchmark ini di Chrome 75 , Firefox 67 , Safari 12 dan Opera 62 .

Saya belum memasukkan Edge dan IE karena saya tidak memilikinya di mesin ini, tetapi jika seseorang dari Anda ingin menjalankan skrip terhadap Edge dan setidaknya IE 9 dan membagikan hasilnya di sini saya akan sangat penasaran untuk melihat hasilnya.

Hanya ingat bahwa Anda perlu membuat ulang 3 string panjang dan menyimpan skrip dalam file yang kemudian Anda buka di browser Anda karena copy / paste pada konsol browser akan memblokirnya karena setiap panjang string adalah> = 1.000.000).

Berikut ini hasilnya:

Chrome 75 ( substringmenang):

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}

Firefox 67 ( indexOfmenang):

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}

Safari 12 ( slicemenang untuk hasil palsu, startsWithmenang untuk hasil nyata, juga Safari adalah yang tercepat dalam hal total waktu untuk melaksanakan seluruh tes):

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

Opera 62 ( substringmenang. Hasil serupa dengan Chrome dan saya tidak terkejut karena Opera didasarkan pada Chromium dan Blink):

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}

Ternyata setiap browser memiliki detail implementasi sendiri (selain Opera, yang didasarkan pada Chromium dan Blink Chrome).

Tentu saja, pengujian lebih lanjut dengan kasus penggunaan yang berbeda dapat dan harus dilakukan (misalnya ketika jarum sangat pendek dibandingkan dengan tumpukan jerami, ketika tumpukan jerami lebih pendek dari jarum, dll ...), tetapi dalam kasus saya, saya perlu membandingkan string yang sangat panjang dan ingin membagikannya di sini.

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

Berdasarkan jawaban di sini, ini adalah versi yang saya gunakan sekarang, karena tampaknya memberikan kinerja terbaik berdasarkan pengujian JSPerf (dan secara fungsional lengkap sejauh yang saya tahu).

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

Ini didasarkan pada beginWith2 dari sini: http://jsperf.com/startswith2/6 . Saya menambahkan tweak kecil untuk peningkatan kinerja kecil, dan sejak itu juga menambahkan cek untuk string perbandingan menjadi nol atau tidak terdefinisi, dan mengubahnya untuk menambah prototipe String menggunakan teknik dalam jawaban CMS.

Perhatikan bahwa implementasi ini tidak mendukung parameter "posisi" yang disebutkan di halaman Jaringan Pengembang Mozilla ini , tetapi itu tampaknya tidak menjadi bagian dari proposal ECMAScript.

Saya tidak yakin untuk javascript tetapi dalam naskah saya melakukan sesuatu seperti

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

Saya kira itu harus bekerja pada js juga. Saya harap ini membantu!

Jika Anda bekerja startsWith()dan endsWith()kemudian Anda harus berhati-hati dalam memimpin ruang. Ini adalah contoh lengkapnya:

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

Anda juga dapat mengembalikan semua anggota array yang dimulai dengan string dengan membuat prototipe / ekstensi Anda sendiri ke prototipe array, alias

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

Dan untuk menggunakannya:

var myArray = ['Hello', 'Helium', 'Hideout', 'Hamster'];
var myResult = myArray.mySearch('Hel');
// result -> Hello, Helium