berakhirDengan JavaScript

Bagaimana saya bisa memeriksa apakah string diakhiri dengan karakter tertentu dalam JavaScript?

Contoh: Saya punya string

var str = "mystring#";

Saya ingin tahu apakah string itu diakhiri dengan #. Bagaimana saya bisa memeriksanya?

1. Apakah ada endsWith()metode dalam JavaScript?

2. Salah satu solusi yang saya miliki adalah mengambil panjang string dan mendapatkan karakter terakhir dan memeriksanya.

Apakah ini cara terbaik atau ada cara lain?

UPDATE (24 Nov 2015):

Jawaban ini awalnya diposting pada tahun 2010 (ENAM tahun yang lalu.) Jadi harap perhatikan komentar yang berwawasan luas ini:

• Shauna - Pembaruan untuk Googler - Sepertinya ECMA6 menambahkan fungsi ini. Artikel MDN juga menunjukkan polyfill. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• TJ Crowder - Membuat substring tidak mahal pada browser modern; mungkin pada tahun 2010 ketika jawaban ini diposting. Saat ini, this.substr(-suffix.length) === suffixpendekatan sederhana tercepat di Chrome, sama di IE11 dengan indexOf, dan hanya 4% lebih lambat (wilayah fergetaboutit) di Firefox: jsperf.com/endswith-stackoverflow/14 Dan lebih cepat di papan ketika hasilnya salah: jsperf.com/endswith-stackoverflow-when-false Tentu saja, dengan menambahkan ES6 berakhir Dengan, intinya adalah diperdebatkan. :-)

JAWABAN ASLI:

Saya tahu ini adalah pertanyaan berumur satu tahun ... tapi saya perlu ini juga dan saya membutuhkannya untuk bekerja lintas-browser jadi ... menggabungkan jawaban dan komentar semua orang dan sedikit menyederhanakannya:

String.prototype.endsWith = function(suffix) {
    return this.indexOf(suffix, this.length - suffix.length) !== -1;
};

• Tidak membuat substring
• Menggunakan indexOffungsi asli untuk hasil tercepat
• Lewati perbandingan yang tidak perlu menggunakan parameter kedua indexOfuntuk melompat ke depan
• Bekerja di Internet Explorer
• TIDAK ADA komplikasi Regex

Juga, jika Anda tidak suka memasukkan hal-hal dalam prototipe struktur data asli, berikut ini adalah versi mandiri:

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

EDIT: Seperti dicatat oleh @hamish di komentar, jika Anda ingin berbuat salah di sisi aman dan memeriksa apakah suatu implementasi telah disediakan, Anda bisa menambahkan typeofcek seperti:

if (typeof String.prototype.endsWith !== 'function') {
    String.prototype.endsWith = function(suffix) {
        return this.indexOf(suffix, this.length - suffix.length) !== -1;
    };
}

/#$/.test(str)

akan bekerja pada semua browser, tidak memerlukan patch monyet String, dan tidak memerlukan pemindaian seluruh string seperti lastIndexOfhalnya ketika tidak ada kecocokan.

Jika Anda ingin mencocokkan string konstan yang mungkin berisi karakter khusus ekspresi reguler, seperti '$', maka Anda dapat menggunakan yang berikut:

function makeSuffixRegExp(suffix, caseInsensitive) {
  return new RegExp(
      String(suffix).replace(/[$%()*+.?\[\\\]{|}]/g, "\\$&") + "$",
      caseInsensitive ? "i" : "");
}

dan kemudian Anda bisa menggunakannya seperti ini

makeSuffixRegExp("a[complicated]*suffix*").test(str)

1. Sayangnya tidak.
2. if( "mystring#".substr(-1) === "#" ) {}

Ayo, ini adalah endsWithimplementasi yang benar :

String.prototype.endsWith = function (s) {
  return this.length >= s.length && this.substr(this.length - s.length) == s;
}

menggunakan lastIndexOfhanya menciptakan loop CPU yang tidak perlu jika tidak ada kecocokan.

Versi ini menghindari membuat substring, dan tidak menggunakan ekspresi reguler (beberapa jawaban regex di sini akan berfungsi; yang lain rusak):

String.prototype.endsWith = function(str)
{
    var lastIndex = this.lastIndexOf(str);
    return (lastIndex !== -1) && (lastIndex + str.length === this.length);
}

Jika kinerja penting bagi Anda, sebaiknya uji apakah lastIndexOfsebenarnya lebih cepat daripada membuat substring atau tidak. (Ini mungkin tergantung pada mesin JS yang Anda gunakan ...) Mungkin lebih cepat dalam kasus yang cocok, dan ketika string kecil - tetapi ketika string besar itu perlu melihat kembali melalui semuanya bahkan meskipun kami tidak terlalu peduli :(

Untuk memeriksa satu karakter, menemukan panjang dan menggunakan charAtmungkin merupakan cara terbaik.

Tidak melihat apporach dengan slicemetode. Jadi saya tinggalkan saja di sini:

function endsWith(str, suffix) {
    return str.slice(-suffix.length) === suffix
}

return this.lastIndexOf(str) + str.length == this.length;

tidak berfungsi dalam kasus di mana panjang string asli kurang dari panjang string pencarian dan string pencarian tidak ditemukan:

lastIndexOf mengembalikan -1, lalu Anda menambahkan panjang string pencarian dan Anda dibiarkan dengan panjang string asli.

Perbaikan yang mungkin adalah

return this.length >= str.length && this.lastIndexOf(str) + str.length == this.length

Dari developer.mozilla.org String.prototype.endsWith ()

Ringkasan

The endsWith()Metode menentukan apakah string berakhir dengan karakter dari string lain, kembali benar atau salah yang sesuai.

Sintaksis

str.endsWith(searchString [, position]);

Parameter

• searchString : Karakter yang akan dicari di akhir string ini.

• posisi : Cari di dalam string ini seolah-olah string ini hanya selama ini; default untuk panjang aktual string ini, dijepit dalam rentang yang ditentukan oleh panjang string ini.

Deskripsi

Metode ini memungkinkan Anda menentukan apakah suatu string berakhir atau tidak.

Contohnya

var str = "To be, or not to be, that is the question.";

alert( str.endsWith("question.") );  // true
alert( str.endsWith("to be") );      // false
alert( str.endsWith("to be", 19) );  // true

Spesifikasi

Spesifikasi Bahasa ECMAScript Edisi 6 (ECMA-262)

Kompatibilitas browser

if( ("mystring#").substr(-1,1) == '#' )

-- Atau --

if( ("mystring#").match(/#$/) )

String.prototype.endsWith = function(str) 
{return (this.match(str+"$")==str)}

String.prototype.startsWith = function(str) 
{return (this.match("^"+str)==str)}

saya harap ini membantu

var myStr = “  Earth is a beautiful planet  ”;
var myStr2 = myStr.trim();  
//==“Earth is a beautiful planet”;

if (myStr2.startsWith(“Earth”)) // returns TRUE

if (myStr2.endsWith(“planet”)) // returns TRUE

if (myStr.startsWith(“Earth”)) 
// returns FALSE due to the leading spaces…

if (myStr.endsWith(“planet”)) 
// returns FALSE due to trailing spaces…

cara tradisional

function strStartsWith(str, prefix) {
    return str.indexOf(prefix) === 0;
}

function strEndsWith(str, suffix) {
    return str.match(suffix+"$")==suffix;
}

Saya tidak tahu tentang Anda, tetapi:

var s = "mystring#";
s.length >= 1 && s[s.length - 1] == '#'; // will do the thing!

Mengapa menggunakan ekspresi reguler? Mengapa mengacaukan prototipe? substr? Ayo...

Hanya alternatif cepat lain yang bekerja seperti pesona bagi saya, menggunakan regex:

// Would be equivalent to:
// "Hello World!".endsWith("World!")
"Hello World!".match("World!$") != null

Jika Anda menggunakan lodash :

_.endsWith('abc', 'c'); // true

Jika tidak menggunakan lodash, Anda dapat meminjam dari sumbernya .

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.

function strEndsWith(str,suffix) {
  var reguex= new RegExp(suffix+'$');

  if (str.match(reguex)!=null)
      return true;

  return false;
}

Begitu banyak hal untuk masalah sekecil ini, cukup gunakan Ekspresi Reguler ini

var str = "mystring#";
var regex = /^.*#$/

if (regex.test(str)){
  //if it has a trailing '#'
}

Sudah bertahun-tahun untuk pertanyaan ini. Biarkan saya menambahkan pembaruan penting untuk pengguna yang ingin menggunakan jawaban chakrit yang paling banyak dipilih.

Fungsi 'endsWith' sudah ditambahkan ke JavaScript sebagai bagian dari ECMAScript 6 (teknologi eksperimental)

Rujuk di sini: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Oleh karena itu sangat disarankan untuk menambahkan cek untuk keberadaan implementasi asli seperti yang disebutkan dalam jawaban.

function check(str)
{
    var lastIndex = str.lastIndexOf('/');
    return (lastIndex != -1) && (lastIndex  == (str.length - 1));
}

Cara untuk bukti di masa depan dan / atau mencegah penimpaan prototipe yang ada akan menjadi tes untuk melihat apakah sudah ditambahkan ke prototipe String. Inilah pendapat saya tentang versi berperingkat tinggi non-regex.

if (typeof String.endsWith !== 'function') {
    String.prototype.endsWith = function (suffix) {
        return this.indexOf(suffix, this.length - suffix.length) !== -1;
    };
}

Jawaban chakrit yang diterima adalah cara yang solid untuk melakukannya sendiri. Namun, jika Anda sedang mencari solusi paket, saya sarankan melihat underscore.string , seperti yang ditunjukkan @mlunoe. Menggunakan underscore.string, kodenya adalah:

function endsWithHash(str) {
  return _.str.endsWith(str, '#');
}

jika Anda tidak ingin menggunakan lasIndexOf atau substr maka mengapa tidak melihat string dalam keadaan alami (mis. sebuah array)

String.prototype.endsWith = function(suffix) {
    if (this[this.length - 1] == suffix) return true;
    return false;
}

atau sebagai fungsi mandiri

function strEndsWith(str,suffix) {
    if (str[str.length - 1] == suffix) return true;
    return false;
}

String.prototype.endWith = function (a) {
    var isExp = a.constructor.name === "RegExp",
    val = this;
    if (isExp === false) {
        a = escape(a);
        val = escape(val);
    } else
        a = a.toString().replace(/(^\/)|(\/$)/g, "");
    return eval("/" + a + "$/.test(val)");
}

// example
var str = "Hello";
alert(str.endWith("lo"));
alert(str.endWith(/l(o|a)/));

Setelah semua penghitungan yang panjang itu, saya menemukan potongan kode ini sederhana dan mudah dimengerti!

function end(str, target) {
  return str.substr(-target.length) == target;
}

Ini adalah implementasi dari tujuan dengan: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }

Ini adalah implementasi dari endsWith:

String.prototype.endsWith = function (str) {
  return (this.length >= str.length) && (this.substr(this.length - str.length) === str);
}

Ini didasarkan pada jawaban yang diterima @ charkit yang memungkinkan Array string, atau string untuk diteruskan sebagai argumen.

if (typeof String.prototype.endsWith === 'undefined') {
    String.prototype.endsWith = function(suffix) {
        if (typeof suffix === 'String') {
            return this.indexOf(suffix, this.length - suffix.length) !== -1;
        }else if(suffix instanceof Array){
            return _.find(suffix, function(value){
                console.log(value, (this.indexOf(value, this.length - value.length) !== -1));
                return this.indexOf(value, this.length - value.length) !== -1;
            }, this);
        }
    };
}

Ini memerlukan underscorejs - tetapi mungkin dapat disesuaikan untuk menghapus ketergantungan garis bawah.

if(typeof String.prototype.endsWith !== "function") {
    /**
     * String.prototype.endsWith
     * Check if given string locate at the end of current string
     * @param {string} substring substring to locate in the current string.
     * @param {number=} position end the endsWith check at that position
     * @return {boolean}
     *
     * @edition ECMA-262 6th Edition, 15.5.4.23
     */
    String.prototype.endsWith = function(substring, position) {
        substring = String(substring);

        var subLen = substring.length | 0;

        if( !subLen )return true;//Empty string

        var strLen = this.length;

        if( position === void 0 )position = strLen;
        else position = position | 0;

        if( position < 1 )return false;

        var fromIndex = (strLen < position ? strLen : position) - subLen;

        return (fromIndex >= 0 || subLen === -fromIndex)
            && (
                position === 0
                // if position not at the and of the string, we can optimise search substring
                //  by checking first symbol of substring exists in search position in current string
                || this.charCodeAt(fromIndex) === substring.charCodeAt(0)//fast false
            )
            && this.indexOf(substring, fromIndex) === fromIndex
        ;
    };
}

Manfaat:

• Versi ini tidak hanya menggunakan kembali indexOf.
• Performa terbaik di string panjang. Berikut ini adalah tes kecepatan http://jsperf.com/starts-ends-with/4
• Sepenuhnya kompatibel dengan spesifikasi ecmascript. Itu melewati tes

Jangan gunakan ekspresi reguler. Mereka lambat bahkan dalam bahasa cepat. Tulis saja fungsi yang memeriksa ujung string. Perpustakaan ini memiliki contoh yang bagus: groundjs / util.js . Hati-hati menambahkan fungsi ke String.prototype. Kode ini memiliki contoh yang bagus tentang bagaimana melakukannya: groundjs / prototype.js Secara umum, ini adalah pustaka tingkat bahasa yang bagus: groundjs Anda juga dapat melihat pada lodash

semuanya adalah contoh yang sangat berguna. Menambahkan String.prototype.endsWith = function(str)akan membantu kita cukup memanggil metode untuk memeriksa apakah string kita berakhir atau tidak, juga regexp juga akan melakukannya.

Saya menemukan solusi yang lebih baik daripada solusi saya. Terimakasih semuanya.

Untuk naskah kopi

String::endsWith = (suffix) ->
  -1 != @indexOf suffix, @length - suffix.length