javascript जावास्क्रिप्ट में समाप्त होता है




string ends-with (24)

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

जावास्क्रिप्ट में एक विशेष चरित्र के साथ एक स्ट्रिंग समाप्त होने पर मैं कैसे जांच सकता हूं?

उदाहरण: मेरे पास एक स्ट्रिंग है

var str = "mystring#";

मैं जानना चाहता हूं कि वह स्ट्रिंग # साथ समाप्त हो रही है या नहीं। मैं इसे कैसे देख सकता हूं?

  1. जावास्क्रिप्ट में एक endsWith() विधि है?

  2. मेरे पास एक समाधान स्ट्रिंग की लंबाई लेता है और अंतिम चरित्र प्राप्त करता है और इसे जांचता है।

क्या यह सबसे अच्छा तरीका है या कोई और तरीका है?


कॉफ़ीस्क्रिप्ट के लिए

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

7 साल की पोस्ट, लेकिन मैं शीर्ष कुछ पदों को समझने में सक्षम नहीं था, क्योंकि वे जटिल हैं। तो, मैंने अपना खुद का समाधान लिखा:

function strEndsWith(str, endwith)
{
    var lastIndex = url.lastIndexOf(endsWith);
    var result = false;
    if (lastIndex > 0 && (lastIndex + "registerc".length) == url.length)
    {
        result = true;
    }
    return result;
}

उन सभी लंबे जवाबों के बाद, मुझे कोड का यह टुकड़ा सरल और समझने में आसान पाया!

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

यदि आप lodash का उपयोग कर रहे हैं:

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

यदि लॉनाश का उपयोग नहीं करते हैं, तो आप इसके source से उधार ले सकते हैं।


इस सवाल के लिए कई सालों रहे हैं। मुझे उन उपयोगकर्ताओं के लिए एक महत्वपूर्ण अपडेट जोड़ने दें जो सर्वाधिक वोटित चक्र का जवाब उपयोग करना चाहते हैं।

ईसीएमएस्क्रिप्ट 6 (प्रयोगात्मक प्रौद्योगिकी) के हिस्से के रूप में 'समाप्त होता है' कार्यों को जावास्क्रिप्ट में पहले ही जोड़ा जा चुका है

इसे यहां देखें: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

इसलिए उत्तर में वर्णित मूल कार्यान्वयन के अस्तित्व की जांच को जोड़ने की अत्यधिक अनुशंसा की जाती है।


वे सभी बहुत उपयोगी उदाहरण हैं। String.prototype.endsWith = function(str) हमें यह सुनिश्चित करने के लिए विधि को कॉल करने में मदद करेगा कि क्या हमारी स्ट्रिंग इसके साथ समाप्त होती है या नहीं, अच्छी तरह से regexp भी ऐसा करेगा।

मुझे मेरी तुलना में एक बेहतर समाधान मिला। सबको धन्यवाद।


यह संस्करण एक सबस्ट्रिंग बनाने से बचाता है, और नियमित अभिव्यक्तियों का उपयोग नहीं करता है (यहां कुछ रेगेक्स उत्तर काम करेंगे; अन्य टूटे हुए हैं):

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

यदि आपके लिए प्रदर्शन महत्वपूर्ण है, तो यह परीक्षण करने योग्य होगा कि lastIndexOf वास्तव में एक सबस्ट्रिंग बनाने से तेज है या नहीं। (यह आपके द्वारा उपयोग किए जा रहे जेएस इंजन पर निर्भर हो सकता है ...) यह मिलान करने वाले मामले में तेज़ी से हो सकता है, और जब स्ट्रिंग छोटा होता है - लेकिन जब स्ट्रिंग बहुत बड़ी होती है तो उसे पूरी चीज़ को वापस देखने की आवश्यकता होती है हालांकि हम वास्तव में परवाह नहीं करते हैं :(

एक चरित्र की जांच करने के लिए, लंबाई ढूंढना और फिर charAt का उपयोग करना शायद सबसे अच्छा तरीका है।


चलो, यह सही endsWith कार्यान्वयन के साथ:

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

अंतिम lastIndexOf का उपयोग करके अगर कोई मैच नहीं है तो केवल अनावश्यक सीपीयू लूप बनाता है।


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

उस मामले में काम नहीं करता है जहां मूल स्ट्रिंग लंबाई खोज स्ट्रिंग लंबाई से कम है और खोज स्ट्रिंग नहीं मिली है:

lastIndex वापसी 1 के बाद, आप खोज स्ट्रिंग लंबाई जोड़ते हैं और आपको मूल स्ट्रिंग की लंबाई के साथ छोड़ दिया जाता है।

एक संभावित फिक्स है

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

भविष्य के सबूत के लिए एक तरीका और / या मौजूदा प्रोटोटाइप की ओवरराइटिंग को रोकने के लिए परीक्षण जांच होगी यह देखने के लिए कि क्या यह स्ट्रिंग प्रोटोटाइप में पहले ही जोड़ा जा चुका है या नहीं। यहां गैर-रेगेक्स अत्यधिक रेटेड संस्करण पर मेरा लेना है।

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

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 विनिर्देश के साथ पूरी तरह से संगत। यह tests पास करता है

नियमित अभिव्यक्तियों का प्रयोग न करें। वे तेजी से भाषाओं में भी धीमी हैं। बस एक फ़ंक्शन लिखें जो स्ट्रिंग के अंत की जांच करता है। इस पुस्तकालय में अच्छे उदाहरण हैं: groundjs/util.js String.prototype पर फ़ंक्शन जोड़ने से सावधान रहें। इस कोड में यह कैसे किया जाए इसके अच्छे उदाहरण हैं: groundjs/prototype.js सामान्यतः, यह एक अच्छी भाषा-स्तर की लाइब्रेरी है: groundjs आप groundjs भी एक नज़र डाल सकते हैं


इतनी छोटी समस्या के लिए इतनी सारी चीज़ें, बस इस नियमित अभिव्यक्ति का उपयोग करें

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

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


यह @ चरकिट के स्वीकार्य उत्तर पर बनाता है या तो स्ट्रिंग के ऐरे की अनुमति देता है, या एक तर्क के रूप में पारित करने के लिए स्ट्रिंग।

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( ("mystring#").substr(-1,1) == '#' )

- या -

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

मैं तुम्हारे बारे में नहीं जानता, लेकिन:

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

नियमित अभिव्यक्ति क्यों? प्रोटोटाइप के साथ गड़बड़ क्यों? substr? चलो ...


  1. दुर्भाग्य से नहीं।
  2. if( "mystring#".substr(-1) === "#" ) {}

slice विधि के साथ apporach नहीं देखा था। तो मैं इसे यहाँ छोड़ दूंगा:

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

अद्यतन (24 नवंबर, 2015):

यह उत्तर मूल रूप से वर्ष 2010 (छह साल पहले) में पोस्ट किया गया है, इसलिए कृपया इन अंतर्दृष्टिपूर्ण टिप्पणियों पर ध्यान दें:

  • Shauna - Googlers के लिए अद्यतन - ऐसा लगता है कि ECMA6 इस समारोह को जोड़ता है। एमडीएन लेख भी एक पॉलीफिल दिखाता है। https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

  • टीजे पाउडर - सब्सट्रिंग बनाना आधुनिक ब्राउज़रों पर महंगा नहीं है; यह 2010 में हो सकता है जब यह उत्तर पोस्ट किया गया था। इन दिनों, सरल this.substr(-suffix.length) === suffix दृष्टिकोण क्रोम पर सबसे तेज़ है, आईई 11 पर इंडेक्स के रूप में, और फ़ायरफ़ॉक्स पर केवल 4% धीमी (fergetaboutit क्षेत्र): jsperf.com/endswith-/14 और जब परिणाम गलत होता है तो बोर्ड में तेज़ी से: jsperf.com/endswith--when-false बेशक, ईएस 6 जोड़ने के साथ अंत में, बिंदु मंथन है। :-)

मूल उत्तर:

मुझे पता है कि यह एक साल का सवाल है ... लेकिन मुझे इसकी भी आवश्यकता है और मुझे इसे क्रॉस-ब्राउजर पर काम करने की ज़रूरत है ... इसलिए हर किसी के जवाब और टिप्पणियों को जोड़कर इसे थोड़ा सा सरल बनाना:

String.prototype.endsWith = function(suffix) {
    return this.indexOf(suffix, this.length - suffix.length) !== -1;
};
  • एक सबस्ट्रिंग नहीं बनाता है
  • सबसे तेज़ परिणामों के लिए फ़ंक्शन के मूल indexOf उपयोग करता है
  • आगे छोड़ने के लिए indexOf के दूसरे पैरामीटर का उपयोग करके अनावश्यक तुलना छोड़ें
  • इंटरनेट एक्सप्लोरर में काम करता है
  • कोई 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;
    };
}

रेगेक्स का उपयोग करके, मेरे लिए एक आकर्षण की तरह काम करने वाला एक और त्वरित विकल्प:

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

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

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

  return false;
}

@ चक्रित का स्वीकार्य उत्तर स्वयं इसे करने का एक ठोस तरीका है। यदि, हालांकि, आप एक पैकेज किए गए समाधान की तलाश में हैं, तो मैं underscore.string पर एक नज़र डालने की सलाह देता हूं, क्योंकि @mlunoe ने बताया। अंडरस्कोर.स्ट्रिंग का उपयोग करके, कोड होगा:

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

/#$/.test(str)

सभी ब्राउज़रों पर काम करेगा, बंदर पैचिंग String आवश्यकता नहीं है, और पूरे स्ट्रिंग को स्कैनिंग की आवश्यकता नहीं है क्योंकि अंतिम मैच है जब कोई मेल नहीं होता है।

यदि आप निरंतर स्ट्रिंग से मेल खाना चाहते हैं जिसमें नियमित अभिव्यक्ति विशेष वर्ण हो सकते हैं, जैसे '$' , तो आप निम्न का उपयोग कर सकते हैं:

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

और फिर आप इसे इस तरह इस्तेमाल कर सकते हैं

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






ends-with