สิ้นสุดด้วย JavaScript

ฉันจะตรวจสอบว่าสตริงลงท้ายด้วยอักขระเฉพาะใน JavaScript ได้อย่างไร?

ตัวอย่าง: ฉันมีสตริง

var str = "mystring#";

#ฉันต้องการที่จะรู้ว่าถ้าสตริงที่ลงท้ายด้วย ฉันจะตรวจสอบได้อย่างไร

1. มีendsWith()วิธีใน JavaScript หรือไม่?

2. ทางออกหนึ่งที่ฉันมีคือใช้ความยาวของสตริงและรับอักขระตัวสุดท้ายและตรวจสอบ

นี่เป็นวิธีที่ดีที่สุดหรือมีวิธีอื่นหรือไม่?

อัปเดต (24 พฤศจิกายน 2558):

คำตอบนี้มีการโพสต์ครั้งแรกในปี 2010 (หกปีที่ผ่านมา) ดังนั้นโปรดรับทราบความคิดเห็นที่ลึกซึ้งเหล่านี้:

• Shauna - อัปเดตสำหรับชาว Google - ดูเหมือนว่า ECMA6 จะเพิ่มฟังก์ชั่นนี้ บทความ MDN ยังแสดง polyfill https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• TJ Crowder - การสร้างสารตั้งต้นไม่แพงในเบราว์เซอร์สมัยใหม่ มันอาจจะดีในปี 2010 เมื่อคำตอบนี้ถูกโพสต์ ทุกวันนี้this.substr(-suffix.length) === suffixวิธีการที่ง่ายและเร็วที่สุดสำหรับ Chrome เช่นเดียวกับ IE11 เช่นเดียวกับ indexOf และช้าลงเพียง 4% (อาณาเขต fergetaboutit) บน Firefox: jsperf.com/endswith-stackoverflow/14และเร็วขึ้นทั่วกระดานเมื่อผลลัพธ์เป็นเท็จ: jsperf.com/endswith-stackoverflow-when-false แน่นอนว่าด้วยการเพิ่ม ES6 สิ้นสุดลงด้วยจุดที่เป็นที่สงสัย :-)

คำตอบเดิม:

ฉันรู้ว่านี่เป็นคำถามอายุหนึ่งปี ... แต่ฉันต้องการสิ่งนี้เช่นกันและฉันต้องการให้ทำงานข้ามเบราว์เซอร์ดังนั้น ... รวมคำตอบและความคิดเห็นของทุกคนเข้าด้วยกันและทำให้มันง่ายขึ้นเล็กน้อย:

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

• ไม่สร้างสตริงย่อย
• ใช้indexOfฟังก์ชันเนทีฟเพื่อผลลัพธ์ที่เร็วที่สุด
• ข้ามการเปรียบเทียบที่ไม่จำเป็นโดยใช้พารามิเตอร์ตัวที่สองของindexOfเพื่อข้ามไปข้างหน้า
• ทำงานใน Internet Explorer
• ไม่มีอาการแทรกซ้อนของ Regex

นอกจากนี้หากคุณไม่ชอบการบรรจุสิ่งต่าง ๆ ในต้นแบบของโครงสร้างข้อมูลดั้งเดิมนี่เป็นเวอร์ชั่นสแตนด์อโลน:

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

แก้ไข:ตามที่บันทึกไว้โดย @hamish ในความคิดเห็นหากคุณต้องการทำผิดในด้านความปลอดภัยและตรวจสอบว่ามีการใช้งานแล้วคุณสามารถเพิ่มtypeofเช็คดังนี้:

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

/#$/.test(str)

จะทำงานบนเบราว์เซอร์ทั้งหมดไม่จำเป็นต้องใช้การแก้ไขลิงStringและไม่จำเป็นต้องสแกนสตริงทั้งหมดเช่นเดียวกับlastIndexOfเมื่อไม่ตรง

หากคุณต้องการจับคู่สตริงคงที่ที่อาจมีอักขระพิเศษนิพจน์ทั่วไปเช่น'$'จากนั้นคุณสามารถใช้สิ่งต่อไปนี้:

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

และจากนั้นคุณสามารถใช้มันเช่นนี้

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

1. แต่น่าเสียดายที่ไม่ได้.
2. if( "mystring#".substr(-1) === "#" ) {}

มาเลยนี่เป็นการendsWithใช้งานที่ถูกต้อง:

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

ใช้lastIndexOfเพียงแค่สร้างลูป CPU ที่ไม่จำเป็นหากไม่มีการจับคู่

รุ่นนี้หลีกเลี่ยงการสร้างซับสตริงและไม่ใช้นิพจน์ทั่วไป (คำตอบของ regex บางส่วนจะใช้งานได้

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

หากประสิทธิภาพเป็นสิ่งสำคัญสำหรับคุณการทดสอบนั้นคุ้มค่าlastIndexOfกว่าการสร้างซับสตริงหรือไม่ (มันอาจขึ้นอยู่กับเอ็นจิ้น JS ที่คุณใช้ ... ) มันอาจจะเร็วกว่าในกรณีที่ตรงกันและเมื่อสตริงมีขนาดเล็ก - แต่เมื่อสตริงมีขนาดใหญ่ก็จำเป็นต้องมองย้อนกลับไปถึงสิ่งต่าง ๆ ทั้งหมด แม้ว่าเราจะไม่สนใจจริงๆ :(

สำหรับการตรวจสอบอักขระเดี่ยวการค้นหาความยาวและการใช้charAtอาจเป็นวิธีที่ดีที่สุด

ไม่เห็น apporach ด้วยsliceวิธีการ ดังนั้นฉันแค่ปล่อยไว้ที่นี่:

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

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

ไม่ทำงานในกรณีที่ความยาวสตริงดั้งเดิมน้อยกว่าความยาวสตริงการค้นหาและไม่พบสตริงการค้นหา:

lastIndexOf ส่งคืน -1 จากนั้นคุณเพิ่มความยาวสตริงการค้นหาและคุณเหลือความยาวสตริงเดิม

การแก้ไขที่เป็นไปได้คือ

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

จาก developer.mozilla.org String.prototype.endsWith ()

สรุป

endsWith()วิธีการกำหนดว่าสตริงปลายกับตัวละครของสตริงอื่นกลับมาจริงหรือเท็จตามความเหมาะสม

วากยสัมพันธ์

str.endsWith(searchString [, position]);

พารามิเตอร์

• searchString : อักขระที่จะค้นหาในตอนท้ายของสตริงนี้

• position : ค้นหาภายในสายนี้ราวกับว่าสายนี้ยาวแค่นี้ ค่าเริ่มต้นกับความยาวที่แท้จริงของสตริงนี้ถูกจับอยู่ในช่วงที่กำหนดโดยความยาวของสตริงนี้

ลักษณะ

วิธีนี้ช่วยให้คุณกำหนดได้ว่าสตริงจะลงท้ายด้วยสตริงอื่นหรือไม่

ตัวอย่าง

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

ข้อมูลจำเพาะ

ข้อมูลจำเพาะภาษา ECMAScript รุ่นที่ 6 (ECMA-262)

ความเข้ากันได้ของเบราว์เซอร์

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

-- หรือ --

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

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

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

ฉันหวังว่านี่จะช่วยได้

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…

วิธีแบบดั้งเดิม

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

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

ฉันไม่รู้เกี่ยวกับคุณ แต่:

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

ทำไมต้องมีการแสดงออกปกติ ทำไมต้องยุ่งกับต้นแบบ? substr? C'mon ...

อีกทางเลือกหนึ่งอย่างรวดเร็วที่ทำงานเหมือนมีเสน่ห์สำหรับฉันโดยใช้ regex:

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

หากคุณใช้lodash :

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

ถ้าไม่ได้ใช้ lodash คุณสามารถกู้ยืมเงินจากของแหล่งที่มา

ฉันเพิ่งเรียนรู้เกี่ยวกับไลบรารีสตริงนี้:

http://stringjs.com/

รวมไฟล์ js แล้วใช้Sตัวแปรเช่นนี้:

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

มันยังสามารถใช้ใน NodeJS โดยติดตั้ง:

npm install string

จากนั้นกำหนดให้เป็นSตัวแปร:

var S = require('string');

หน้าเว็บยังมีลิงก์ไปยังไลบรารีสตริงทางเลือกด้วยหากหน้าเว็บนี้ไม่ใช้ความคิดของคุณ

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

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

  return false;
}

หลายสิ่งหลายอย่างสำหรับปัญหาเล็ก ๆ นี้เพียงใช้นิพจน์ปกตินี้

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

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

เป็นเวลาหลายปีสำหรับคำถามนี้ ให้ฉันเพิ่มการอัปเดตที่สำคัญสำหรับผู้ใช้ที่ต้องการใช้คำตอบของ chakrit ที่ได้รับการโหวตมากที่สุด

ฟังก์ชัน 'endsWith' ถูกเพิ่มไปยัง JavaScript แล้วซึ่งเป็นส่วนหนึ่งของ ECMAScript 6 (เทคโนโลยีทดลอง)

อ้างอิงได้ที่นี่: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

ดังนั้นจึงขอแนะนำอย่างยิ่งให้เพิ่มการตรวจสอบการมีอยู่ของการใช้งานตามที่ระบุไว้ในคำตอบ

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

วิธีการพิสูจน์ในอนาคตและ / หรือป้องกันการเขียนทับต้นแบบที่มีอยู่จะเป็นการตรวจสอบการทดสอบเพื่อดูว่ามันได้ถูกเพิ่มไปยังต้นแบบเครื่องสายแล้วหรือไม่ นี่คือสิ่งที่ฉันใช้ในเวอร์ชันที่ไม่ได้รับการจัดอันดับสูง

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

@chakrit คำตอบที่ได้รับการยอมรับเป็นวิธีที่มั่นคงในการทำด้วยตัวเอง อย่างไรก็ตามหากคุณกำลังมองหาโซลูชันสำเร็จรูปฉันแนะนำให้ดูunderscore.stringตามที่ @ mlunoe ชี้ให้เห็น ใช้ underscore.string โค้ดจะเป็น:

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

หากคุณไม่ต้องการใช้ lasIndexOf หรือ substr ทำไมไม่ลองดูที่สตริงในสภาพธรรมชาติ (เช่น. array)

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

หรือเป็นฟังก์ชันสแตนด์อโลน

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

หลังจากคำตอบที่มีมานานแล้วฉันพบว่าโค้ดชิ้นนี้เรียบง่ายและเข้าใจง่าย!

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

นี่คือการดำเนินการสิ้นสุดด้วย: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }

นี่คือการดำเนินการของendsWith:

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

สิ่งนี้สร้างขึ้นจากคำตอบที่ได้รับการยอมรับของ @ charkit ซึ่งอนุญาตให้มี Array ของสตริงหรือสตริงที่จะส่งผ่านเป็นอาร์กิวเมนต์

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

สิ่งนี้ต้องใช้เครื่องหมายขีดล่าง - แต่อาจปรับได้เพื่อลบการอ้างอิงขีดล่าง

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

ประโยชน์ที่ได้รับ:

• รุ่นนี้ไม่ได้เป็นเพียงการใช้ indexOf อีกครั้ง
• ประสิทธิภาพที่ยอดเยี่ยมสำหรับสายยาว นี่คือการทดสอบความเร็วhttp://jsperf.com/starts-ends-with/4
• เข้ากันได้อย่างสมบูรณ์กับข้อกำหนด ecmascript มันผ่านการทดสอบ

อย่าใช้นิพจน์ทั่วไป มันช้าแม้ในภาษาที่รวดเร็ว เพียงเขียนฟังก์ชั่นที่ตรวจสอบจุดสิ้นสุดของสตริง ห้องสมุดนี้มีตัวอย่างที่ดี: groundjs / util.js ระวังการเพิ่มฟังก์ชั่นใน String.prototype รหัสนี้มีตัวอย่างที่ดีเกี่ยวกับวิธีการทำ: groundjs / prototype.js โดยทั่วไปนี่เป็นไลบรารี่ระดับภาษาที่ดี: groundjs คุณยังสามารถดู Lodash

พวกเขาทั้งหมดเป็นตัวอย่างที่มีประโยชน์มาก การเพิ่มString.prototype.endsWith = function(str)จะช่วยให้เราเรียกวิธีการนั้นเพื่อตรวจสอบว่าสตริงของเราลงท้ายด้วยหรือไม่ regexp ที่ดีก็จะทำเช่นนั้น

ฉันพบทางออกที่ดีกว่าของฉัน ขอบคุณทุกคน

สำหรับกาแฟ

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