दिलचस्प पोस्ट
जावा का उपयोग करके बाल्टी में सभी एडब्लूएस एस 3 ऑब्जेक्ट्स को कैसे सूचीबद्ध किया जाए कैसे CGCeyCode ASCII चरित्र को परिवर्तित करने के लिए? __stdcall क्या है? अजगर "के साथ" क्या डिज़ाइन किया गया है? क्रोम डेवलपमेंट टूल्स / फायरबग / आईई डेवलपर टूलबार का उपयोग करके एक तत्व की संलग्न / बाध्य घटनाओं का पता लगाएं मैं गिट में गलत कमिट संदेश को कैसे संपादित करूं (जो मैंने धकेल दिया है)? Global.asax में सत्र का अंत कैसे नियंत्रित करें? रिलीज कॉम ऑब्जेक्ट बनाम फाइनलरेलीकॉम ऑब्जेक्ट का उपयोग कब किया जाए? जब मेरी क्रैश हो जाती है तो मेरी प्रक्रिया के लिए मिनीडम्प कैसे बनाएं? मैं struct के संदर्भ के लिए Add attribute को कैसे लागू करूं? एसक्यूएल में कोमा से अलग परिणाम जावा एसई 6 बनाम जेआरई 1.6 बनाम जेडीके 1.6 – इसका क्या मतलब है? डेटाफ़्रेम से कई तत्व निकालने का मानक तरीका स्ट्रिंग इन जावा में एक पूरे शब्द कैसे खोजें मैं डेल्फी में सी यूनियन का अनुवाद कैसे करूं?

जावास्क्रिप्ट में एक स्ट्रिंग में एक वर्ण की घटनाओं की संख्या की गणना करें

मुझे स्ट्रिंग में एक वर्ण की घटनाओं की संख्या की गणना करने की आवश्यकता है।

उदाहरण के लिए, मान लें कि मेरी स्ट्रिंग में शामिल हैं:

var mainStr = "str1,str2,str3,str4"; 

मैं अल्पविराम , चरित्र, जो 3 है की गणना करना चाहता हूँ। और अल्पविराम के साथ विभाजित होने के बाद व्यक्तिगत स्ट्रिंग्स की गिनती, जो 4 है

मुझे यह भी मान्य करने की आवश्यकता है कि प्रत्येक स्ट्रिंग यानी स्ट्रोब या स्ट्रॉ 2 या स्ट्रॉस या स्ट्रॉफ़ी को 15 वर्णों से अधिक नहीं होना चाहिए।

Solutions Collecting From Web of "जावास्क्रिप्ट में एक स्ट्रिंग में एक वर्ण की घटनाओं की संख्या की गणना करें"

मैंने इस उत्तर को अपडेट किया है। मुझे बेहतर मैच का उपयोग करने का विचार पसंद है, लेकिन यह धीमा है:

 console.log(("str1,str2,str3,str4".match(/,/g) || []).length); //logs 3 console.log(("str1,str2,str3,str4".match(new RegExp("str", "g")) || []).length); //logs 4 

jsfiddle

नियमित रूप से एक अभिव्यक्ति का प्रयोग करें यदि आप जानते हैं कि आप पहले से क्या खोज रहे हैं, यदि आप RegExp कन्स्ट्रक्टर का उपयोग नहीं कर सकते हैं, और तर्क के रूप में g फ्लैग में पास कर सकते हैं।

match रिटर्न null साथ कोई परिणाम नहीं है || [] || []

2009 में मैंने जो मूल उत्तर दिया था वह नीचे है यह अनावश्यक रूप से एक सरणी बनाता है, लेकिन एक विभाजन का उपयोग तेजी से है (सितंबर 2014 तक)। मैं विवादास्पद हूं, अगर मुझे वास्तव में गति की ज़रूरत है तो कोई सवाल ही नहीं होगा कि मैं एक विभाजन का उपयोग करेगा, लेकिन मैं मैच का उपयोग करना पसंद करूंगा।

पुराने उत्तर (2009 से):

यदि आप अल्पविराम की तलाश कर रहे हैं:

 (mainStr.split(",").length - 1) //3 

यदि आप str देख रहे हैं

 (mainStr.split("str").length - 1) //4 

@ लो के जवाब में दोनों और मेरी अपनी मूर्खतापूर्ण jsperf परीक्षण विभाजन में कम से कम क्रोम में, गति में आगे आता है, लेकिन फिर से अतिरिक्त सरणी बनाने से सिर्फ समझदार नहीं लगता।

कम से कम चार तरीके हैं सबसे अच्छा विकल्प, जो देशी RegEx इंजन के लिए सबसे तेजी से बढ़ रहा होना चाहिए -, शीर्ष पर रखा गया है jsperf.com वर्तमान में नीचे है, अन्यथा मैं आपको प्रदर्शन आंकड़ों के साथ प्रदान करेगा।

अद्यतन करें : कृपया, यहां प्रदर्शन के प्रदर्शनों को ढूंढें, और उन्हें स्वयं चलाएं, ताकि आपके प्रदर्शन परिणामों में योगदान किया जा सके परिणामों की बारीकियों को बाद में दिया जाएगा।

1।

  ("this is foo bar".match(/o/g)||[]).length //>2 

2।

 "this is foo bar".split("o").length-1 //>2 

विभाजन की सिफारिश नहीं है संसाधन भूख लगी प्रत्येक मैच के लिए 'एरे' के नए संस्करण का आवंटन करता है। फ़ाइल> रीडर के जरिये> 100 एमबी फ़ाइल के लिए कोशिश न करें। आप वास्तव में क्रोम के प्रोफाइलर विकल्प का उपयोग करके सटीक संसाधन उपयोग को आसानी से देख सकते हैं।

3।

 var stringsearch = "o" ,str = "this is foo bar"; for(var count=-1,index=-2; index != -1; count++,index=str.indexOf(stringsearch,index+1) ); //>count:2 

4।

एक एकल वर्ण के लिए खोज

 var stringsearch = "o" ,str = "this is foo bar"; for(var i=count=0; i<str.length; count+=+(stringsearch===str[i++])); //>count:2 

अद्यतन करें:

5।

तत्व मैपिंग और फ़िल्टरिंग, इसके समग्र संसाधन प्रीलाक्लेक्शन की वजह से अनुशंसित नहीं है, बल्कि पायथोनियन 'जेनरेटर'

 var str = "this is foo bar" str.split('').map( function(e,i){ if(e === 'o') return i;} ) .filter(Boolean) //>[9, 10] [9, 10].length //>2 

शेयर करें: मैं इस सार को वर्तमान में चरित्र-गिनती के 8 तरीकों के साथ बनाया है, इसलिए हम मज़े के लिए और शायद कुछ दिलचस्प मानक – हमारे विचार साझा कर सकते हैं और साझा कर सकते हैं 🙂

https://gist.github.com/2757250

त्वरित Google खोज को यह ( http://www.codecodex.com/wiki/index.php?title=Count_the_number_of_occurrences_of_a_specific_character_in_a_string # जावास्क्रिप्ट से ) मिला है

 String.prototype.count=function(s1) { return (this.length - this.replace(new RegExp(s1,"g"), '').length) / s1.length; } 

इसे इस तरह प्रयोग करें:

 test = 'one,two,three,four' commas = test.count(',') // returns 3 

स्टिंग प्रोटोटाइप के लिए इस फ़ंक्शन को जोड़ें:

 String.prototype.count=function(c) { var result = 0, i = 0; for(i;i<this.length;i++)if(this[i]==c)result++; return result; }; 

उपयोग:

 console.log("strings".count("s")); //2 

ठीक है, एक दूसरे के साथ regexp – शायद तेजी से नहीं, लेकिन कम और बेहतर पठनीय अन्य तो, मेरे मामले में सिर्फ '_' गिनती के लिए

 key.replace(/[^_]/g,'').length 

बस सब कुछ हटा दें जो आपके चारों तरह दिखता नहीं है, लेकिन यह इनपुट के रूप में एक स्ट्रिंग के साथ अच्छा नहीं दिखता है

मैंने पाया है कि एक बहुत बड़ी स्ट्रिंग (जो कि 1 000 000 वर्ण लंबा है) में एक वर्ण की खोज करने के लिए सबसे अच्छा तरीका है replace() विधि का उपयोग करना है

 window.count_replace = function (str, schar) { return str.length - str.replace(RegExp(schar), '').length; }; 

स्ट्रिंग में एक पात्र को खोजने के अन्य तरीकों के साथ आप इस विधि का परीक्षण करने के लिए एक अन्य जेएसपीरफ़ सुइट देख सकते हैं।

मैं एक छोटी परियोजना पर काम कर रहा था जिसके लिए उप-स्ट्रिंग काउंटर की आवश्यकता थी। गलत वाक्यांशों की तलाश में मुझे कोई परिणाम नहीं मिला, हालांकि अपने स्वयं के कार्यान्वयन को लिखने के बाद मैंने इस प्रश्न पर ठोकर खाई है। वैसे भी, यह मेरा तरीका है, यह शायद सबसे ज्यादा यहां धीमी है लेकिन किसी के लिए उपयोगी हो सकता है:

 function count_letters() { var counter = 0; for (var i = 0; i < input.length; i++) { var index_of_sub = input.indexOf(input_letter, i); if (index_of_sub > -1) { counter++; i = index_of_sub; } } 

http://jsfiddle.net/5ZzHt/1/

कृपया मुझे बताएं कि क्या आप इस कार्यान्वयन को विफल करने या कुछ मानकों का पालन नहीं करते हैं! 🙂

अद्यतन करें आप विकल्प चुन सकते हैं:

  for (var i = 0; i < input.length; i++) { 

साथ में:

 for (var i = 0, input_length = input.length; i < input_length; i++) { 

दिलचस्प उपर्युक्त चर्चा करते हुए पढ़ें: http://www.erichynds.com/blog/javascript-length-property-is-a-stored-value

मैंने स्वीकार किए गए उत्तर में मामूली सुधार किया है, यह केस-संवेदी / केस-असंवेदनशील मिलान से जांचने की अनुमति देता है, और एक स्ट्रिंग ऑब्जेक्ट से जुड़ी विधि है:

 String.prototype.count = function(lit, cis) { var m = this.toString().match(new RegExp(lit, ((cis) ? "gi" : "g"))); return (m != null) ? m.length : 0; } 

lit की खोज करने वाली स्ट्रिंग है (जैसे 'पूर्व'), और सीआईएस केस-असंवेदनशीलता है, जो गलत है, यह केस असंवेदनशील मैचों की पसंद के लिए अनुमति देगा।


लोअर-केस 'o' लिए 'I love StackOverflow.com' स्ट्रिंग खोजने के लिए, आप इसका उपयोग करेंगे:

 var amount_of_os = 'I love StackOverflow.com'.count('o'); 

amount_of_os 2 बराबर होगा


अगर हम केस-असंवेदनशील मिलान का उपयोग करके एक ही स्ट्रिंग फिर से खोज रहे थे, तो आप इसका प्रयोग करेंगे:

 var amount_of_os = 'I love StackOverflow.com'.count('o', true); 

इस बार, amount_of_os 3 बराबर होगा, क्योंकि स्ट्रिंग से पूंजी O को खोज में शामिल किया गया है।

Split बनाम RegExp का प्रदर्शन

 var i = 0; var split_start = new Date().getTime(); while (i < 30000) { "1234,453,123,324".split(",").length -1; i++; } var split_end = new Date().getTime(); var split_time = split_end - split_start; i= 0; var reg_start = new Date().getTime(); while (i < 30000) { ("1234,453,123,324".match(/,/g) || []).length; i++; } var reg_end = new Date().getTime(); var reg_time = reg_end - reg_start; alert ('Split Execution time: ' + split_time + "\n" + 'RegExp Execution time: ' + reg_time + "\n"); 

सबसे आसान तरीका मुझे पता चला …

उदाहरण-

 str = 'mississippi'; function find_occurences(str, char_to_count){ return str.split(char_to_count).length - 1; } find_occurences(str, 'i') //outputs 4 

यहां एक समान समाधान है, लेकिन यह कम करने का उपयोग करता है

 function countCharacters(char, string) { return string.split('').reduce((acc, ch) => ch === char ? acc + 1: acc, 0) } 

जैसा कि उल्लेख किया गया था, जगह की तुलना में बहुत तेजी से विभाजित।

 s = 'dir/dir/dir/dir/' for(i=l=0;i<s.length;i++) if(s[i] == '/') l++ 

स्ट्रिंग.split (वांछित चेरेक्टर) के बारे में क्या है। लांघ -1

उदाहरण:

var str = "नरक कैसे जीवन है"; var len = str.split ("h")। लंबाई -1; उपरोक्त स्ट्रिंग में वर्ण "h" के लिए गिनती 2 देगी;

मैं Node.js v.6.0.0 का उपयोग कर रहा हूं और सबसे तेजी से इंडेक्स के साथ एक है (लो सॉर के उत्तर में तीसरी विधि)।

दूसरा है:

 function count(s, c) { var n = 0; for (let x of s) { if (x == c) n++; } return n; } 

यदि आप रद्दी का उपयोग कर रहे हैं, तो _

 _.countBy("abcda")['a'] //2 

यह विधि भी सरणी के साथ काम करती है:

 _.countBy(['ab', 'cd', 'ab'])['ab'] //2 

विभाजित और प्रतिस्थापन तरीकों के रूप में लगभग एक ही रूप में तेज़ है, जो क्रोम पर () में रीजेक्स विधि की तुलना में थोड़ा सा तेज है।

 var num = 0; for (ch of "str1,str2,str3,str4") { if (ch === ',') num++; } 

निम्नलिखित लंबाई का परीक्षण करने के लिए एक नियमित अभिव्यक्ति का उपयोग करता है testex सुनिश्चित करता है कि आपके पास 16 या अधिक लगातार गैर-अल्पविराम अक्षरों न हो। यदि यह परीक्षण पास करता है, तो यह स्ट्रिंग को विभाजित करने के लिए आय करता है। अल्पविराम की गिनती टोकन ऋण की गणना के रूप में सरल है I

 var mainStr = "str1,str2,str3,str4"; var testregex = /([^,]{16,})/g; if (testregex.test(mainStr)) { alert("values must be separated by commas and each may not exceed 15 characters"); } else { var strs = mainStr.split(','); alert("mainStr contains " + strs.length + " substrings separated by commas."); alert("mainStr contains " + (strs.length-1) + " commas."); } 

मेरा समाधान:

 function countOcurrences(str, value){ var regExp = new RegExp(value, "gi"); return str.match(regExp) ? str.match(regExp).length : 0; } 

मैंने नोड v7.4 का उपयोग करते हुए repl.it पर एक बहुत ही त्वरित और गंदे परीक्षण किया। एकल वर्ण के लिए, लूप के लिए मानक तेज़ है:

कुछ कोड :

 // winner! function charCount1(s, c) { let count = 0; c = c.charAt(0); // we save some time here for(let i = 0; i < s.length; ++i) { if(c === s.charAt(i)) { ++count; } } return count; } function charCount2(s, c) { return (s.match(new RegExp(c[0], 'g')) || []).length; } function charCount3(s, c) { let count = 0; for(ch of s) { if(c === ch) { ++count; } } return count; } function perfIt() { const s = 'Hello, World!'; const c = 'o'; console.time('charCount1'); for(let i = 0; i < 10000; i++) { charCount1(s, c); } console.timeEnd('charCount1'); console.time('charCount2'); for(let i = 0; i < 10000; i++) { charCount2(s, c); } console.timeEnd('charCount2'); console.time('charCount3'); for(let i = 0; i < 10000; i++) { charCount2(s, c); } console.timeEnd('charCount3'); } 

कुछ रनों के परिणाम :

  perfIt() charCount1: 3.843ms charCount2: 11.614ms charCount3: 11.470ms => undefined perfIt() charCount1: 3.006ms charCount2: 8.193ms charCount3: 7.941ms => undefined perfIt() charCount1: 2.539ms charCount2: 7.496ms charCount3: 7.601ms => undefined perfIt() charCount1: 2.654ms charCount2: 7.540ms charCount3: 7.424ms => undefined perfIt() charCount1: 2.950ms charCount2: 9.445ms charCount3: 8.589ms 

लियो सॉर्स के पांचवें तरीके का जवाब विफल हो जाता है, यदि अक्षर स्ट्रिंग की शुरुआत में होता है जैसे

 var needle ='A', haystack = 'AbcAbcAbc'; haystack.split('').map( function(e,i){ if(e === needle) return i;} ) .filter(Boolean).length; 

2 के बजाय 2 देगा, क्योंकि फिल्टर फ़ुटबूल बूलियन 0 के लिए झूठी देता है।

अन्य संभव फ़िल्टर फ़ंक्शन:

 haystack.split('').map(function (e, i) { if (e === needle) return i; }).filter(function (item) { return !isNaN(item); }).length; 

मुझे पता है कि यह एक पुराना सवाल हो सकता है लेकिन मेरे पास जावास्क्रिप्ट में निम्न-स्तरीय शुरुआती के लिए एक सरल उपाय है।

एक शुरुआत के रूप में, मैं इस प्रश्न के कुछ समाधानों को समझ सकता था, इसलिए मैंने प्रत्येक चरित्र को प्रत्येक अक्षर के खिलाफ स्ट्रिंग में जांचने के लिए प्रत्येक नेस्टेड लूप का उपयोग किया, प्रत्येक वर्ण के लिए एक गिनती चर बढ़ाना, जो उस वर्ण के बराबर है।

मैंने एक नया रिक्त ऑब्जेक्ट बनाया जहां प्रत्येक प्रॉपर्टी कुंजी एक कैरेक्टर है और वैल्यू कितनी बार स्ट्रिंग (गिनती) में प्रत्येक अक्षर दिखाई देती है।

उदाहरण फ़ंक्शन: –

 function countAllCharacters(str) { var obj = {}; if(str.length!==0){ for(i=0;i<str.length;i++){ var count = 0; for(j=0;j<str.length;j++){ if(str[i] === str[j]){ count++; } } if(!obj.hasOwnProperty(str[i])){ obj[str[i]] = count; } } } return obj; } 

मेरा मानना ​​है कि आपको बहुत कम, बहुत तेज़ होने के लिए नीचे दिए गए समाधान मिलेंगे, बहुत लंबे स्ट्रिंग के साथ काम करने में सक्षम होंगे, कई चरित्र खोजों का समर्थन करने में, त्रुटि सबूत और रिक्त स्ट्रिंग खोजों को संभालने में सक्षम होंगे।

 function substring_count(source_str, search_str, index) { source_str += "", search_str += ""; var count = -1, index_inc = Math.max(search_str.length, 1); index = (+index || 0) - index_inc; do { ++count; index = source_str.indexOf(search_str, index + index_inc); } while (~index); return count; } 

उदाहरण उपयोग:

 console.log(substring_count("Lorem ipsum dolar un sit amet.", "m ")) function substring_count(source_str, search_str, index) { source_str += "", search_str += ""; var count = -1, index_inc = Math.max(search_str.length, 1); index = (+index || 0) - index_inc; do { ++count; index = source_str.indexOf(search_str, index + index_inc); } while (~index); return count; }