स्ट्रिंग में स्ट्रिंग की घटना की गणना कैसे करें?

Question

मैं किसी विशेष स्ट्रिंग को किसी अन्य स्ट्रिंग में कितनी बार गिन सकता हूं। उदाहरण के लिए, यह वही है जो मैं जावास्क्रिप्ट में करने की कोशिश कर रहा हूं:

var temp = "This is a string.";
alert(temp.count("is")); //should output '2'

Comments

यह इस बात पर निर्भर करता है कि क्या आप अतिव्यापी उदाहरण स्वीकार करते हैं , जैसे var t = "sss"; उपरोक्त स्ट्रिंग में "ss" के कितने उदाहरण हैं? 1 या 2? क्या आप प्रत्येक उदाहरण पर छलांग लगाते हैं, या सूचक चरित्र-दर-वर्ण को स्थानांतरित करते हैं, विकल्प की तलाश कर रहे हैं?

— टिम

इस प्रश्न के उत्तर के लिए एक बेहतर बेंचमार्क: jsperf.com/string-ocurrence-split-vs-match/2 (काज़ज़िक के बेंचमार्क के आधार पर)।

— इदमन

Answer 1

gनियमित अभिव्यक्ति (के लिए कम में वैश्विक ) पूरी स्ट्रिंग खोज करने के लिए के बजाय सिर्फ पहली घटना लगता है कहते हैं। यह isदो बार मेल खाता है :

var temp = "This is a string.";
var count = (temp.match(/is/g) || []).length;
console.log(count);

और, अगर कोई मिलान नहीं है, तो यह रिटर्न 0:

var temp = "Hello World!";
var count = (temp.match(/is/g) || []).length;
console.log(count);

Comments

आधुनिक और सुरुचिपूर्ण, लेकिन विटिमटेक का समाधान अधिक कुशल है। आप सभी उसके कोड के बारे में क्या सोचते हैं?

— TruMan1

यह सवाल का सबसे अच्छा जवाब देता है। अगर किसी ने पूछा कि "मैं विशेष मामले में (regexps के बिना) यह 10x तेज़ी से कैसे कर सकता हूं" विटिम्टक वह सवाल जीत जाएगा।

— द्घाहुघ्न

इसके लिए धन्यवाद .. count = (str.match(/is/g) || []).lengthअगर आपके पास मैच नहीं है तो मैं संभालूंगा।

— मैट

मुझे नहीं लगता कि यह उत्तर ठीक से प्रश्न से मेल खाता है, क्योंकि यह मैच के तर्क के रूप में उपयोग नहीं करता है, जैसा कि उपयोग मामला वर्णन करता है। निश्चित रूप से, आप विधायक का उपयोग करते हुए गतिशील रूप से regexp बना सकते हैं RegExpऔर उस स्ट्रिंग को पास कर सकते हैं जिसकी आप तलाश कर रहे हैं, लेकिन उस स्थिति में आपको सभी मेटाचैकर्स से बचना होगा। उस परिदृश्य में, एक शुद्ध स्ट्रिंग दृष्टिकोण बेहतर है।

— ZER0

मैट का जवाब जवाब में होना चाहिए!

— सेनसी

Answer 2

/** Function that count occurrences of a substring in a string;
 * @param {String} string               The string
 * @param {String} subString            The sub string to search for
 * @param {Boolean} [allowOverlapping]  Optional. (Default:false)
 *
 * @author Vitim.us https://gist.github.com/victornpb/7736865
 * @see Unit Test https://jsfiddle.net/Victornpb/5axuh96u/
 * @see http://stackoverflow.com/questions/4009756/how-to-count-string-occurrence-in-string/7924240#7924240
 */
function occurrences(string, subString, allowOverlapping) {

    string += "";
    subString += "";
    if (subString.length <= 0) return (string.length + 1);

    var n = 0,
        pos = 0,
        step = allowOverlapping ? 1 : subString.length;

    while (true) {
        pos = string.indexOf(subString, pos);
        if (pos >= 0) {
            ++n;
            pos += step;
        } else break;
    }
    return n;
}

प्रयोग

occurrences("foofoofoo", "bar"); //0

occurrences("foofoofoo", "foo"); //3

occurrences("foofoofoo", "foofoo"); //1

allowOverlapping

occurrences("foofoofoo", "foofoo", true); //2

मेल खाता है:

  foofoofoo
1 `----´
2    `----´

अध्याय परीक्षा

• https://jsfiddle.net/Victornpb/5axuh96u/

बेंचमार्क

मैंने एक बेंचमार्क टेस्ट किया है और मेरा फंक्शन 10 गुना ज्यादा तेज है और फिर रेम्बेक्सप फंक्शन फंक्शन गंबो द्वारा पोस्ट किया गया है। मेरे परीक्षण में स्ट्रिंग 25 वर्णों की लंबाई है। चरित्र 'ओ' के 2 घटनाओं के साथ। मैंने सफारी में 1 000 000 बार निष्पादित किया।

सफारी 5.1

बेंचमार्क> कुल समय निष्पादन: 5617 एमएस (regexp)

बेंचमार्क> कुल समय निष्पादन: 881 एमएस (मेरा कार्य 6.4x तेज)

फ़ायरफ़ॉक्स ४

बेंचमार्क> कुल समय निष्पादन: 8547 एमएस (रेक्सएक्सएक्स)

बेंचमार्क> कुल समय निष्पादन: 634 एमएस (मेरा कार्य 13.5x तेज)

---

संपादित करें: मेरे द्वारा किए गए परिवर्तन

• कैश्ड सबरिंग लंबाई

• स्ट्रिंग में टाइप-कास्टिंग जोड़ा गया।

• जोड़ा गया वैकल्पिक 'allowOverlapping' पैरामीटर

• खाली प्रतिस्थापन मामले के लिए सही आउटपुट तय किया गया।

सार

• https://gist.github.com/victornpb/7736865

Comments

मैंने सफारी 5 में इस परीक्षण को दोहराया और एक छोटे (100 बी) स्ट्रिंग के साथ समान परिणाम मिला, लेकिन एक बड़ी स्ट्रिंग (16 केबी) के साथ, रेगेक्स मेरे लिए तेजी से भाग गया। एक पुनरावृत्ति (1,000,000 नहीं) के लिए, अंतर वैसे भी एक मिलीसेकंड से कम था, इसलिए मेरा वोट रेगेक्स पर जाता है।

— अर्लोमेडिया

+1, लेकिन आप substring.lengthलगभग हर लूप की जांच कर रहे हैं , आपको इसे बाहर कैशिंग करने पर विचार करना चाहिएwhile

— ajax333221

@ ajax333221 OMG आपने मेरे मन को पढ़ा, मैंने कुछ दिन पहले यह सुधार किया था, और मैं अपना जवाब jsperf.com/count-string-occurrence-in-string

— Vitim.us

मुझे आपका कोड यहाँ उपयोग में मिला: success-equation.com/mind_reader.html । वास्तव में अच्छा है प्रोग्रामर ने एक संदर्भ दिया।

— ब्रूनो किम

@DanielZuzevich यह स्ट्रिंग के प्रकारों के लिए बाध्य करेगा , यदि आप करते हैं occurrences(11,1) //2और यह अभी भी काम करेगा। (यह तेजी से टाइप करने के लिए जाँच करने और कॉल करने के बजाय इस तरह से कर रहा है () )

— Vitim.us

Answer 3

function countInstances(string, word) {
   return string.split(word).length - 1;
}

Comments

यह एक असुरक्षित / गलत दृष्टिकोण है, उदाहरण के लिए countInstances("isisisisisis", "is") === 0:।

— निक Craver

@Antal - क्रोम के पिछले बीटा बिल्ड में एक बग जैसा दिखता है, नवीनतम को अपडेट करने के बाद काम करता है, मैं अभी भी इस पद्धति को स्पष्ट करूंगा।

— निक Craver

यह मेरे लिए पूरी तरह से वैध समाधान की तरह दिखता है।

— ग्रेगर श्मिट

@NickCraver जिज्ञासा से बाहर है, तो आप इस पद्धति को स्पष्ट क्यों करना चाहते हैं? (आपके बीटा ब्राउज़र में बग के अलावा)

— जॉनी लिन

@JonnyLin यह अनावश्यक आवंटन बनाता है जिसे आप तुरंत फेंक देते हैं जब विकल्प नहीं होते हैं - डेटा के आधार पर संभावित रूप से बहुत बड़े।

— निक Craver

Answer 4

आप यह कोशिश कर सकते हैं:

var theString = "This is a string.";
console.log(theString.split("is").length - 1);

Comments

सादगी के लिए +1 और क्योंकि मेरे परीक्षणों के अनुसार यह समाधान दूसरों की तुलना में ~ 10x तेज चलता है!

— क्लाउडियो हॉलैंडा

उदाहरण के लिए मेरे पास दो "है" आप प्रत्येक का स्थान कैसे प्राप्त करते हैं?

— रैपिडूड

जैसा कि @Orbit के उत्तर में चर्चा की गई है, लोगों को क्रोम के पुराने संस्करणों पर अलग-अलग परिणाम मिल रहे हैं। मैं शायद इस पद्धति का उपयोग करते हुए थोड़ा सतर्क रहूंगा।

— mgthomas99

और आप इसे चर के साथ भी उपयोग कर सकते हैं: theString.split(myvar).length - 1जिसे आप सरल रीगेक्स के साथ नहीं कर सकते हैं

— स्टीफन

यह तीन साल बाद @ ऑर्बिट का जवाब है ...

— aloisdg codidact.com

Answer 5

मेरा समाधान:

var temp = "This is a string.";

function countOcurrences(str, value) {
  var regExp = new RegExp(value, "gi");
  return (str.match(regExp) || []).length;
}

console.log(countOcurrences(temp, 'is'));

Comments

शायद वापस लौटना बेहतर होगा (str.match (regExp) || [])। लंबाई; इस तरह आप दो बार नियमित अभिव्यक्ति का मूल्यांकन नहीं करते हैं?

— अनिकेरू

आपको अपनी स्ट्रिंग को भी countOcurrences('Hello...','.')==8

— स्कैन

Answer 6

आप matchऐसे फ़ंक्शन को परिभाषित करने के लिए उपयोग कर सकते हैं :

String.prototype.count = function(search) {
    var m = this.match(new RegExp(search.toString().replace(/(?=[.\\+*?[^\]$(){}\|])/g, "\\"), "g"));
    return m ? m.length:0;
}

Comments

यदि आप चाहते हैं कि यह जेएस के खोज शब्दार्थ के साथ एकरूप हो, तो रिटर्न लाइन होगी return m ? m.length:-1;।

— कॉनर ओ'ब्रायन

यह ऊपर के अन्य रेगेक्स समाधानों की तुलना में बेहतर है, क्योंकि वे एक त्रुटि का कारण बनते हैं यदि स्ट्रिंग की घटनाओं को गिनने के लिए "[" या रेगेक्स में एक विशेष अर्थ के साथ कुछ भी हो।

— प्रोग्रामर

Answer 7

गैर-रेगेक्स संस्करण:

 var string = 'This is a string',
    searchFor = 'is',
    count = 0,
    pos = string.indexOf(searchFor);

while (pos > -1) {
    ++count;
    pos = string.indexOf(searchFor, ++pos);
}

console.log(count);   // 2

Comments

1. यह केवल एकल खोज के लिए, बहुत सूक्ष्म है 2. यहां तक ​​कि ओपी भी isघटनाओं के लिए पूछता है

— vladkras

यह शायद यहां सबसे तेज़ कार्यान्वयन है, लेकिन यह और भी तेज़ होगा यदि आप "++ पॉज़" को "पॉस = = सर्चफ़्लो.लॉग" के साथ बदल देते हैं

— हेंशेंरिक

Answer 8

बस कोड-गोल्फ रेबेका Chernoff के समाधान :-)

alert(("This is a string.".match(/is/g) || []).length);

Answer 9

String.prototype.Count = function (find) {
    return this.split(find).length - 1;
}

console.log("This is a string.".Count("is"));

यह 2 लौटेगा।

Comments

यह छह साल बाद @ ऑर्बिट का जवाब है ...

— aloisdg codidact.com के लिए बढ़ रहा है।

Answer 10

यहाँ सबसे तेज़ कार्य है!

यह तेज क्यों है?

• चार (1 अपवाद के साथ) द्वारा चार की जाँच नहीं करता
• थोड़ी देर और वेतन वृद्धि का उपयोग करता है 1 (चार गिनती काउंटर) बनाम लूप के लिए लंबाई की जाँच और 2 vars (आमतौर पर मैं और चर गिनती के साथ एक संस्करण) incrementing
• कम var का उपयोग करता है
• रेगेक्स का उपयोग नहीं करता है!
• (अनुकूलित) अत्यधिक अनुकूलित फ़ंक्शन का उपयोग करता है

• सभी ऑपरेशन जितने संयुक्त हैं, उतने ऑपरेशन के कारण मंदी से बच सकते हैं

  String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'')[0];while(l=this.indexOf(c,l)+1)++t;return t};

यहाँ एक धीमी और अधिक पठनीय संस्करण है:

    String.prototype.timesCharExist = function ( chr ) {
        var total = 0, last_location = 0, single_char = ( chr + '' )[0];
        while( last_location = this.indexOf( single_char, last_location ) + 1 )
        {
            total = total + 1;
        }
        return total;
    };

यह एक काउंटर, लंबे समय के नाम और 1 संस्करण के दुरुपयोग के कारण धीमा है।

इसका उपयोग करने के लिए, आप बस यह करें:

    'The char "a" only shows up twice'.timesCharExist('a');

संपादित करें: (2013/12/16)

ओपेरा 12.16 या पुराने के साथ प्रयोग न करें! यह रेगेक्स समाधान की तुलना में लगभग 2.5x अधिक लेगा!

क्रोम पर, यह समाधान 1,000,000 वर्णों के लिए 14ms और 20ms के बीच ले जाएगा।

रेगेक्स समाधान उसी राशि के लिए 11-14ms लेता है।

एक फ़ंक्शन (बाहर String.prototype) का उपयोग करने में लगभग 10-13ms लगेंगे।

यहाँ इस्तेमाल किया गया कोड है:

    String.prototype.timesCharExist=function(c){var t=0,l=0,c=(c+'')[0];while(l=this.indexOf(c,l)+1)++t;return t};

    var x=Array(100001).join('1234567890');

    console.time('proto');x.timesCharExist('1');console.timeEnd('proto');

    console.time('regex');x.match(/1/g).length;console.timeEnd('regex');

    var timesCharExist=function(x,c){var t=0,l=0,c=(c+'')[0];while(l=x.indexOf(c,l)+1)++t;return t;};

    console.time('func');timesCharExist(x,'1');console.timeEnd('func');

सभी समाधानों का परिणाम 100,000 होना चाहिए!

नोट: यदि आप हैं, तो परिवर्तन इस समारोह की तुलना में अधिक 1 वर्ण की गणना करना चाहते हैं जहां है c=(c+'')[0]मेंc=c+''

Comments

प्रोटोटाइप एक उदाहरण था! आप कृपया फ़ंक्शन का उपयोग कर सकते हैं! आप यह भी कर सकते हैं: var timesFunctionExist = function (x, c) {var t = 0, l = 0, c = (c + '') [0]; जबकि (l = x.indexOf (c, l) +1; ) ++ टी; रिटर्न टी}); सतर्क (timesCharExist ('चार "केवल" दो बार दिखाता है', 'ए')) (यह थोड़ा और अधिक कारण होगा क्योंकि मैं प्रोटोटाइप के साथ खिलवाड़ नहीं करूंगा)। अगर आपको लगता है कि मैं गलत हूं, तो आप मुझ पर पत्थर फेंकने से पहले क्यों नहीं दिखाते? मुझे साबित करो कि मेरा कार्य बेकार है और मैं इसे स्वीकार करूंगा। मुझे एक टेस्ट केस दिखाओ। और var की लंबाई गति पर प्रभाव डालती है। आप इसका परीक्षण कर सकते हैं।

— इस्माईल मिगुएल

Answer 11

var temp = "This is a string.";
console.log((temp.match(new RegExp("is", "g")) || []).length);

Answer 12

मुझे लगता है कि रेगेक्स का उद्देश्य इससे बहुत अलग है indexOf। indexOfबस एक निश्चित स्ट्रिंग के रोचकता का पता लगाएं, जबकि रेगेक्स में आप वाइल्डकार्ड का उपयोग कर सकते हैं, [A-Z]जिसका अर्थ है कि यह वास्तविक चरित्र को बताए बिना शब्द में कोई भी पूंजी वर्ण पाएगा ।

उदाहरण:

 var index = "This is a string".indexOf("is");
 console.log(index);
 var length = "This is a string".match(/[a-z]/g).length;
 // where [a-z] is a regex wildcard expression thats why its slower
 console.log(length);

Answer 13

सुपर डुपर पुराना, लेकिन मुझे आज ऐसा कुछ करने की जरूरत थी और केवल एसओ की जांच करने के लिए सोचा। मेरे लिए बहुत तेजी से काम करता है।

String.prototype.count = function(substr,start,overlap) {
    overlap = overlap || false;
    start = start || 0;

    var count = 0, 
        offset = overlap ? 1 : substr.length;

    while((start = this.indexOf(substr, start) + offset) !== (offset - 1))
        ++count;
    return count;
};

Answer 14

       var myString = "This is a string.";
        var foundAtPosition = 0;
        var Count = 0;
        while (foundAtPosition != -1)
        {
            foundAtPosition = myString.indexOf("is",foundAtPosition);
            if (foundAtPosition != -1)
            {
                Count++;
                foundAtPosition++;
            }
        }
        document.write("There are " + Count + " occurrences of the word IS");

देखें: - स्टेप बाई स्टेप स्पष्टीकरण के लिए स्ट्रिंग में एक सबरिंग की गणना करें ।

Answer 15

ऊपर Vittim.us उत्तर पर @ बिल्डिंग। मुझे वह नियंत्रण पसंद है जो उसकी विधि मुझे देती है, जिससे मुझे विस्तार करना आसान हो जाता है, लेकिन मुझे मामले की असंवेदनशीलता को जोड़ने और विराम चिह्न के लिए पूरे शब्दों के साथ मैच को सीमित करने की आवश्यकता है। (उदाहरण के लिए "स्नान" "स्नान में।" लेकिन "स्नान" नहीं है)

विराम चिह्न regex कहां से आया: https://stackoverflow.com/a/25575009/497745 ( मैं regex का उपयोग करके जावास्क्रिप्ट में स्ट्रिंग से सभी विराम चिह्न कैसे हटा सकता हूं? )

function keywordOccurrences(string, subString, allowOverlapping, caseInsensitive, wholeWord)
{

    string += "";
    subString += "";
    if (subString.length <= 0) return (string.length + 1); //deal with empty strings

    if(caseInsensitive)
    {            
        string = string.toLowerCase();
        subString = subString.toLowerCase();
    }

    var n = 0,
        pos = 0,
        step = allowOverlapping ? 1 : subString.length,
        stringLength = string.length,
        subStringLength = subString.length;

    while (true)
    {
        pos = string.indexOf(subString, pos);
        if (pos >= 0)
        {
            var matchPos = pos;
            pos += step; //slide forward the position pointer no matter what

            if(wholeWord) //only whole word matches are desired
            {
                if(matchPos > 0) //if the string is not at the very beginning we need to check if the previous character is whitespace
                {                        
                    if(!/[\s\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&\(\)*+,\-.\/:;<=>?@\[\]^_`{|}~]/.test(string[matchPos - 1])) //ignore punctuation
                    {
                        continue; //then this is not a match
                    }
                }

                var matchEnd = matchPos + subStringLength;
                if(matchEnd < stringLength - 1)
                {                        
                    if (!/[\s\u2000-\u206F\u2E00-\u2E7F\\'!"#$%&\(\)*+,\-.\/:;<=>?@\[\]^_`{|}~]/.test(string[matchEnd])) //ignore punctuation
                    {
                        continue; //then this is not a match
                    }
                }
            }

            ++n;                
        } else break;
    }
    return n;
}

यदि आप बग्स या सुधारों को सुधारते हैं तो कृपया इस उत्तर को संशोधित और परिष्कृत करें।

Answer 16

है कि भविष्य में इस सूत्र पाता है किसी के लिए, नोट स्वीकार किए जाते हैं जवाब हमेशा सही मूल्य वापस नहीं करेगा अगर आप इसे सामान्य है, क्योंकि यह की तरह regex ऑपरेटरों पर गला घोंटना होगा $और .। यहाँ एक बेहतर संस्करण है, जो किसी भी सुई को संभाल सकता है :

function occurrences (haystack, needle) {
  var _needle = needle
    .replace(/\[/g, '\\[')
    .replace(/\]/g, '\\]')
  return (
    haystack.match(new RegExp('[' + _needle + ']', 'g')) || []
  ).length
}

Answer 17

function get_occurrence(varS,string){//Find All Occurrences
        c=(string.split(varS).length - 1);
        return c;
    }
    temp="This is a string.";
    console.log("Total Occurrence is "+get_occurrence("is",temp));

स्ट्रिंग में अक्षर और स्ट्रिंग दोनों की घटना को खोजने के लिए get_occurrence (varS, string) का उपयोग करें।

Answer 18

कोशिश करो

<?php 
$str = "33,33,56,89,56,56";
echo substr_count($str, '56');
?>

<script type="text/javascript">
var temp = "33,33,56,89,56,56";
var count = temp.match(/56/g);  
alert(count.length);
</script>

Answer 19

रेगेक्स के बिना सरल संस्करण:

var temp = "This is a string.";

var count = (temp.split('is').length - 1);

alert(count);

Comments

यह छह साल बाद @ ऑर्बिट का जवाब है ...

— aloisdg codidact.com के लिए बढ़ रहा है।

Answer 20

कोई भी कभी भी यह नहीं देखेगा, लेकिन एक बार में पुनरावृत्ति और तीर के कार्यों को वापस लाना अच्छा है (शानदार ढंग से इरादा करना)

String.prototype.occurrencesOf = function(s, i) {
 return (n => (n === -1) ? 0 : 1 + this.occurrencesOf(s, n + 1))(this.indexOf(s, (i || 0)));
};

Answer 21

इसे इस्तेमाल करे

let allData =  "This is a string.";
let searchString = 'is';
let regularExp = new RegExp(searchString, 'g');
let occurArray = allData.match(regularExp);
let count = (occurArray || []).length;
alert(count); 

फिडल लिंक: https://jsfiddle.net/rajaramtt/gn0dtsjc/1/

Answer 22

अब यह एक बहुत पुराना धागा है जो मुझे आया है, लेकिन जैसे ही कई लोगों ने अपना उत्तर दिया है, यहाँ मेरा इस सरल कोड से किसी की मदद करने की उम्मीद है।

var search_value = "This is a dummy sentence!";
var letter = 'a'; /*Can take any letter, have put in a var if anyone wants to use this variable dynamically*/
letter = letter && "string" === typeof letter ? letter : "";
var count;
for (var i = count = 0; i < search_value.length; count += (search_value[i++] == letter));
console.log(count);

मुझे यकीन नहीं है कि यह सबसे तेज़ समाधान है, लेकिन मैंने इसे सादगी के लिए पसंद किया है और रेगेक्स का उपयोग नहीं करने के लिए (मुझे बस उनका उपयोग करना पसंद नहीं है!)

Answer 23

यह फ़ंक्शन पाठ में किसी शब्द की घटनाओं की संख्या लौटाता है।

ध्यान दें कि हम वर्ड और टेक्स्ट के फॉर्मेट (कैपिटल, अपरकेस ...) में होने वाली घटनाओं की संख्या की गणना करने के लिए toLowerCase का उपयोग करते हैं।

wordCount(text, word) {
    if (!text || !word) {
      return 0;
    }
    text = text.toLowerCase();
    word = word.toLowerCase();
    return ( text.split( word ).length - 1 );
}

Answer 24

लिएंड्रो बतिस्ता का जवाब: रेगेक्स एक्सप्रेशन वाली समस्या।

 "use strict";
 var dataFromDB = "testal";
 
  $('input[name="tbInput"]').on("change",function(){
	var charToTest = $(this).val();
	var howManyChars = charToTest.length;
	var nrMatches = 0;
	if(howManyChars !== 0){
		charToTest = charToTest.charAt(0);
		var regexp = new RegExp(charToTest,'gi');
		var arrMatches = dataFromDB.match(regexp);
		nrMatches = arrMatches ? arrMatches.length : 0;
	}
		$('#result').html(nrMatches.toString());

  });

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<div class="main">
What do you wanna count <input type="text" name="tbInput" value=""><br />
Number of occurences = <span id="result">0</span>
</div>

Answer 25

var countInstances = function(body, target) {
  var globalcounter = 0;
  var concatstring  = '';
  for(var i=0,j=target.length;i<body.length;i++){
    concatstring = body.substring(i-1,j);
    
    if(concatstring === target){
       globalcounter += 1;
       concatstring = '';
    }
  }
  
  
  return globalcounter;
 
};

console.log(   countInstances('abcabc', 'abc')   ); // ==> 2
console.log(   countInstances('ababa', 'aba')   ); // ==> 2
console.log(   countInstances('aaabbb', 'ab')   ); // ==> 1

Answer 26

थोड़ी देर लेकिन, यह मानते हुए कि हमारे पास निम्नलिखित स्ट्रिंग हैं:

var temp = "This is a string.";

पहले हम जो कुछ भी आप मैच के लिए देख रहे हैं, उस पर विभाजित हो जाते हैं, इससे स्ट्रिंग्स की एक सरणी वापस आ जाएगी।

var array = temp.split("is");

फिर हम इसकी लंबाई प्राप्त करते हैं और 1 को घटाकर इसे घटाते हैं क्योंकि आकार 1 की एक सरणी में विभाजन को समाप्त कर देता है और परिणाम के अनुसार इसका आकार हर बार घटता है जब यह एक घटना पाता है।

var occurrenceCount = array.length - 1;
alert(occurrenceCount); //should output '2'

आप यह सब एक पंक्ति में निम्नानुसार भी कर सकते हैं:

alert("This is a string.".split("is").length - 1); //should output '2'

आशा है कि यह मदद करता है: डी

Comments

क्या मैं इसे डुप्लिकेट उत्तर के रूप में चिह्नित कर सकता हूं? हो सकता है कि आपको अपना जवाब देने से पहले सभी उत्तरों को पढ़ना चाहिए?

— मिकिएल

यह @Orbit का आठ साल बाद जवाब है ...

— aloisdg codidact.com के लिए बढ़ रहा है

क्या मुझे यह प्रतिक्रिया हटा देनी चाहिए?

— जुआन एनरिक सेजब्रे

Answer 27

यह समाधान उस .replace()पद्धति पर आधारित है जो एक RegEx को पहले पैरामीटर के रूप में स्वीकार करता है और दूसरे पैरामीटर के रूप में एक फ़ंक्शन जिसे हम एक काउंटर को बढ़ाने के लिए एक बंद के रूप में उपयोग कर सकते हैं ...

/**
 * Return the frequency of a substring in a string
 * @param {string} string - The string.
 * @param {string} string - The substring to count.
 * @returns {number} number - The frequency.
 * 
 * @author Drozerah https://gist.github.com/Drozerah/2b8e08d28413d66c3e63d7fce80994ce
 * @see https://stackoverflow.com/a/55670859/9370788
 */
const subStringCounter = (string, subString) => {

    let count = 0
    string.replace(new RegExp(subString, 'gi'), () => count++)
    return count
}

प्रयोग

subStringCounter("foofoofoo", "bar"); //0

subStringCounter("foofoofoo", "foo"); //3

Answer 28

इस पोस्ट के पार आया।

let str = 'As sly as a fox, as strong as an ox';

let target = 'as'; // let's look for it

let pos = 0;
while (true) {
  let foundPos = str.indexOf(target, pos);
  if (foundPos == -1) break;

  alert( `Found at ${foundPos}` );
  pos = foundPos + 1; // continue the search from the next position
}

एक ही एल्गोरिदम को छोटा किया जा सकता है:

let str = "As sly as a fox, as strong as an ox";
let target = "as";

let pos = -1;
while ((pos = str.indexOf(target, pos + 1)) != -1) {
  alert( pos );
}

Answer 29

---

substr_count जावास्क्रिप्ट से जावास्क्रिप्ट के लिए अनुवादित

---

• Locutus (पैकेज जो JS में Php का अनुवाद करता है)
• substr_count (आधिकारिक पृष्ठ, नीचे कॉपी किया गया कोड)

function substr_count (haystack, needle, offset, length) { 
  // eslint-disable-line camelcase
  //  discuss at: https://locutus.io/php/substr_count/
  // original by: Kevin van Zonneveld (https://kvz.io)
  // bugfixed by: Onno Marsman (https://twitter.com/onnomarsman)
  // improved by: Brett Zamir (https://brett-zamir.me)
  // improved by: Thomas
  //   example 1: substr_count('Kevin van Zonneveld', 'e')
  //   returns 1: 3
  //   example 2: substr_count('Kevin van Zonneveld', 'K', 1)
  //   returns 2: 0
  //   example 3: substr_count('Kevin van Zonneveld', 'Z', 0, 10)
  //   returns 3: false

  var cnt = 0

  haystack += ''
  needle += ''
  if (isNaN(offset)) {
    offset = 0
  }
  if (isNaN(length)) {
    length = 0
  }
  if (needle.length === 0) {
    return false
  }
  offset--

  while ((offset = haystack.indexOf(needle, offset + 1)) !== -1) {
    if (length > 0 && (offset + needle.length) > length) {
      return false
    }
    cnt++
  }

  return cnt
}

Php के root_count फ़ंक्शन का Locutus का अनुवाद देखें

Answer 30

इसे इस्तेमाल करे:

function countString(str, search){
    var count=0;
    var index=str.indexOf(search);
    while(index!=-1){
        count++;
        index=str.indexOf(search,index+1);
    }
    return count;
}