javascript - हरण - हिंदी में जावास्क्रिप्ट परिचय




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

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

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

var str = "mystring#";

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

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

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

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


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

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

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

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

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


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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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


यदि आप lasIndexOf या substr का उपयोग नहीं करना चाहते हैं तो क्यों न केवल अपने प्राकृतिक स्थिति (यानी एक सरणी) में स्ट्रिंग को देखें।

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.endsWith = function(str)
{
    var lastIndex = this.lastIndexOf(str);
    return (lastIndex !== -1) && (lastIndex + str.length === this.length);
}

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

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


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

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

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith से https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

सारांश

endsWith() विधि निर्धारित करता है कि कोई स्ट्रिंग किसी अन्य स्ट्रिंग के वर्णों के साथ समाप्त होती है, जो सही या गलत के रूप में लौटती है।

वाक्य - विन्यास

str.endsWith(searchString [, position]);

पैरामीटर

  • searchString : इस स्ट्रिंग के अंत में वर्णों की खोज की जाएगी।

  • स्थिति : इस स्ट्रिंग के भीतर खोजें जैसे कि यह स्ट्रिंग केवल इतना लंबा था; इस स्ट्रिंग की लंबाई तक स्थापित सीमा के भीतर क्लैंप किए गए इस स्ट्रिंग की वास्तविक लंबाई के लिए डिफ़ॉल्ट।

विवरण

यह विधि आपको यह निर्धारित करने देती है कि स्ट्रिंग किसी अन्य स्ट्रिंग के साथ समाप्त होती है या नहीं।

उदाहरण

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

विशेष विवरण

ईसीएमएस्क्रिप्ट भाषा विशिष्टता 6 वां संस्करण (ईसीएमए -262)

ब्राउज़र संगतता


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

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

/#$/.test(str)

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

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

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

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

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

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 check(str)
{
    var lastIndex = str.lastIndexOf('/');
    return (lastIndex != -1) && (lastIndex  == (str.length - 1));
}

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

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

  return false;
}

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 पास करता है

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

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

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

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

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




ends-with