मुझे एक स्ट्रिंग में एक चरित्र की घटनाओं की संख्या की गणना करने की आवश्यकता है।
उदाहरण के लिए, मान लें कि मेरी स्ट्रिंग में निम्न शामिल हैं:
var mainStr = "str1,str2,str3,str4";मैं कॉमा ,चरित्र की गिनती ढूंढना चाहता हूं , जो 3. है और कॉमा के साथ विभाजन के बाद अलग-अलग तारों की गिनती है, जो 4 है।
मुझे यह भी सत्यापित करने की आवश्यकता है कि स्ट्रिंग्स यानी str1 या str2 या str3 या str4 में से प्रत्येक 15 वर्णों से अधिक नहीं होना चाहिए।
जवाबों:
मैंने इसका उत्तर अपडेट कर दिया है। मुझे मैच का बेहतर उपयोग करने का विचार पसंद है, लेकिन यह धीमा है:
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यदि आप जानते हैं कि आप पहले से क्या खोज रहे हैं, यदि आप RegExpकंस्ट्रक्टर का उपयोग नहीं कर सकते हैं , और gध्वज में एक तर्क के रूप में पास करते हैं, तो एक नियमित अभिव्यक्ति शाब्दिक का उपयोग करें ।
matchnullकोई परिणाम नहीं के साथ रिटर्न इस प्रकार|| []
2009 में मेरे द्वारा किया गया मूल उत्तर नीचे है। यह अनावश्यक रूप से एक सरणी बनाता है, लेकिन एक विभाजन का उपयोग तेजी से होता है (सितंबर 2014 तक)। अगर मैं वास्तव में गति की जरूरत है, तो मैं अनुमान लगाता हूं, कोई सवाल नहीं होगा कि मैं एक विभाजन का उपयोग करूं, लेकिन मैं मैच का उपयोग करना पसंद करूंगा।
पुराना उत्तर (2009 से):
यदि आप अल्पविराम की तलाश में हैं:
(mainStr.split(",").length - 1) //3यदि आप str की तलाश कर रहे हैं
(mainStr.split("str").length - 1) //4@ लो के जवाब में और मेरे अपने मूर्खतापूर्ण jsperf टेस्ट विभाजन में गति में आगे, कम से कम क्रोम में, लेकिन फिर से अतिरिक्त सरणी का निर्माण करना समझदारी नहीं है।
कम से कम चार तरीके हैं। सबसे अच्छा विकल्प, जो मूल RegEx इंजन के लिए सबसे तेज़-भी होना चाहिए -, शीर्ष पर रखा गया है। jsperf.com वर्तमान में नीचे है, अन्यथा मैं आपको प्रदर्शन आंकड़े प्रदान करता हूं।
अपडेट : कृपया, यहां प्रदर्शन परीक्षण खोजें, और उन्हें अपने आप चलाएं, ताकि आपके प्रदर्शन परिणामों का योगदान हो सके। परिणामों की बारीकियों को बाद में दिया जाएगा।
("this is foo bar".match(/o/g)||[]).length
//>2"this is foo bar".split("o").length-1
//>2विभाजित नहीं की सिफारिश की। संसाधन भूखा है। प्रत्येक मैच के लिए 'ऐरे' के नए उदाहरण आवंटित करता है। FileReader के माध्यम से> 100MB फ़ाइल के लिए प्रयास न करें। आप वास्तव में Chrome के प्रोफाइलर विकल्प का उपयोग करके EXACT संसाधन उपयोग को आसानी से देख सकते हैं ।
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एक एकल चरित्र के लिए खोज
var stringsearch = "o"
,str = "this is foo bar";
for(var i=count=0; i<str.length; count+=+(stringsearch===str[i++]));
//>count:2अपडेट करें:
तत्व मानचित्रण और फ़िल्टरिंग, पायथोनियन 'जनरेटर' का उपयोग करने के बजाय इसके समग्र संसाधन प्रचार के कारण अनुशंसित नहीं है
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 तरीकों के साथ, - सिर्फ मनोरंजन के लिए है, और शायद कुछ रोचक मानक :)
||[]कर रहा हूं लेकिन यह जवाब बहुत अच्छा है! किसी और के लिए अपने सिर को खरोंचने के लिए, match()रिटर्न nullअगर कोई मैच नहीं मिला है और ||[]0 लंबाई सरणी match()लौटाएगा यदि रिटर्न null, अर्थ length()एक प्रकार की त्रुटि पैदा करने के बजाय 0 वापस आ जाएगा।
index = -2, लेकिन बहुत बहुत धन्यवाद @Augustus
इस फ़ंक्शन को स्टिंग प्रोटोटाइप में जोड़ें:
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"stringsstringstrings".count("str")?
एक त्वरित Google खोज को यह मिला ( http://www.codecodex.com/wiki/index.php?title=Count_the_number_of_occurrences_of_a_specific_character_in_a-string#JavaScript ) से
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बस, एक स्ट्रिंग में एक चरित्र की घटनाओं की संख्या का पता लगाने के लिए विभाजन का उपयोग करें ।
mainStr.split(',').length // 4 देता है जो सीमांकक अल्पविराम का उपयोग करके विभाजित करने की संख्या है
mainStr.split(',').length - 1 // 3 देता है जो अल्पविराम की गिनती है
यहां एक समान समाधान है, लेकिन यह उपयोग करता है Array.prototype.reduce
function countCharacters(char, string) {
return string.split('').reduce((acc, ch) => ch === char ? acc + 1: acc, 0)
}जैसा कि उल्लेख किया गया था, की String.prototype.splitतुलना में बहुत तेजी से काम करता है String.prototype.replace।
मैंने पाया है कि एक बहुत बड़ी स्ट्रिंग में वर्ण की खोज करने के लिए सबसे अच्छा तरीका (जो कि 1 000 000 वर्ण लंबा है, उदाहरण के लिए) replace() विधि है।
window.count_replace = function (str, schar) {
return str.length - str.replace(RegExp(schar), '').length;
};आप एक स्ट्रिंग में एक चरित्र खोजने के अन्य तरीकों के साथ इस विधि का परीक्षण करने के लिए अभी तक एक और JSPerf सूट देख सकते हैं ।
आप अपने स्ट्रिंग को भी आराम कर सकते हैं और इसके साथ काम कर सकते हैं जैसे तत्वों का उपयोग करना
const mainStr = 'str1,str2,str3,str4';
const commas = [...mainStr].filter(l => l === ',').length;
console.log(commas);या
const mainStr = 'str1,str2,str3,str4';
const commas = [...mainStr].reduce((a, c) => c === ',' ? ++a : a, 0);
console.log(commas);मैंने स्वीकार किए गए उत्तर पर थोड़ा सुधार किया, यह केस-संवेदी / केस-असंवेदनशील मिलान के साथ जांच करने की अनुमति देता है, और यह स्ट्रिंग ऑब्जेक्ट से जुड़ी एक विधि है:
String.prototype.count = function(lit, cis) {
var m = this.toString().match(new RegExp(lit, ((cis) ? "gi" : "g")));
return (m != null) ? m.length : 0;
}lit स्ट्रिंग के लिए खोज करने के लिए है (जैसे 'पूर्व'), और सीआईएस केस-असंवेदनशीलता है, झूठे के लिए डिफ़ॉल्ट, यह केस असंवेदनशील मैचों की पसंद की अनुमति देगा।
'I love StackOverflow.com'निम्न-केस पत्र के लिए
स्ट्रिंग की खोज करने के लिए 'o', आप उपयोग करेंगे:
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स्ट्रिंग से पूंजी खोज में शामिल हो जाती है।
स्प्लिट बनाम 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 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;
}
}कृपया मुझे बताएं कि क्या आपको यह कार्यान्वयन विफल लगता है या कुछ मानकों का पालन नहीं करता है! :)
अद्यतन आप स्थानापन्न करना चाह सकते हैं:
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
यदि आप लॉश का उपयोग कर रहे हैं, तो _.countBy विधि ऐसा करेगी:
_.countBy("abcda")['a'] //2यह विधि भी सरणी के साथ काम करती है:
_.countBy(['ab', 'cd', 'ab'])['ab'] //2यहाँ मेरा समाधान है। समाधान के बहुत पहले से ही मेरे सामने तैनात हैं। लेकिन मुझे यहां अपना विचार साझा करना बहुत पसंद है।
const mainStr = 'str1,str2,str3,str4';
const commaAndStringCounter = (str) => {
const commas = [...str].filter(letter => letter === ',').length;
const numOfStr = str.split(',').length;
return `Commas: ${commas}, String: ${numOfStr}`;
}
// Run the code
console.log(commaAndStringCounter(mainStr)); // Output: Commas: 3, String: 4सबसे तेज विधि सूचकांक ऑपरेटर के माध्यम से लगती है:
function charOccurances (str, char)
{
for (var c = 0, i = 0, len = str.length; i < len; ++i)
{
if (str[i] == char)
{
++c;
}
}
return c;
}
console.log( charOccurances('example/path/script.js', '/') ); // 2या एक प्रोटोटाइप फ़ंक्शन के रूप में:
String.prototype.charOccurances = function (char)
{
for (var c = 0, i = 0, len = this.length; i < len; ++i)
{
if (this[i] == char)
{
++c;
}
}
return c;
}
console.log( 'example/path/script.js'.charOccurances('/') ); // 2निम्नलिखित लंबाई का परीक्षण करने के लिए एक नियमित अभिव्यक्ति का उपयोग करता है। टेस्टेक्स सुनिश्चित करता है कि आपके पास 16 या अधिक लगातार गैर-अल्पविराम वर्ण नहीं हैं। यदि यह परीक्षण पास करता है, तो यह स्ट्रिंग को विभाजित करने के लिए आगे बढ़ता है। कॉमा को गिनना उतना ही सरल है जितना कि टोकन माइनस को गिनना।
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.");
}क्या string.split (वांछनीय) के बारे में .length -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;
}यहाँ विभाजन और प्रतिस्थापित विधियों के रूप में लगभग एक तेज़ है, जो रेगेक्स विधि (क्रोम में) की तुलना में थोड़ा तेज है।
var num = 0;
for (ch of "str1,str2,str3,str4")
{
if (ch === ',') num++;
}मैं सिर्फ repl.it पर एक बहुत जल्दी और गंदा परीक्षण किया । Node का उपयोग करके। एकल वर्ण के लिए, लूप के लिए मानक सबसे तेज है:
कुछ कोड :
// 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और वहां है:
function character_count(string, char, ptr = 0, count = 0) {
while (ptr = string.indexOf(char, ptr) + 1) {count ++}
return count
}पूर्णांक के साथ भी काम करता है!
मेरा समाधान:
function countOcurrences(str, value){
var regExp = new RegExp(value, "gi");
return str.match(regExp) ? str.match(regExp).length : 0;
}String.prototype.matchरिटर्न के रूप में काम नहीं करेगा null। इसका मतलब है कि एक lengthविशेषता के साथ एक वस्तु का कोई संदर्भ नहीं है । दूसरे शब्दों में:String.prototype.match.call('willnotwork', /yesitwill/) === null
लियो सॉवर्स जवाब में पांचवीं विधि विफल हो जाती है, अगर चरित्र स्ट्रिंग की शुरुआत में है। जैसे
var needle ='A',
haystack = 'AbcAbcAbc';
haystack.split('').map( function(e,i){ if(e === needle) return i;} )
.filter(Boolean).length;3 के बजाय 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;
}उपरोक्त कोड जकुब वाव्ज़्स्की में प्रमुख प्रदर्शन बग को ठीक करता है, जो कोड को इंडेक्सऑफ के बाद भी मैच के लिए देखता रहता है, कहता है कि कोई भी नहीं है और उसका संस्करण स्वयं काम नहीं कर रहा है क्योंकि वह फ़ंक्शन इनपुट पैरामीटर देना भूल गया है।
var a = "acvbasbb";
var b= {};
for (let i=0;i<a.length;i++){
if((a.match(new RegExp(a[i], "g"))).length > 1){
b[a[i]]=(a.match(new RegExp(a[i], "g"))).length;
}
}
console.log(b);जावास्क्रिप्ट में आप एक स्ट्रिंग में एक चरित्र की घटना प्राप्त करने के लिए ऊपर दिए गए कोड का उपयोग कर सकते हैं।
रामदा जी के साथ मेरा समाधान:
const testString = 'somestringtotest'
const countLetters = R.compose(
R.map(R.length),
R.groupBy(R.identity),
R.split('')
)
countLetters(testString)फ़ंक्शन स्ट्रिंग स्ट्रिंग को पैरामीटर के रूप में लेता है और स्ट्रिंग में प्रत्येक अद्वितीय वर्णों की घटना को गिनता है। परिणाम प्रत्येक चरित्र के लिए कुंजी-मूल्य जोड़ी में आता है।
var charFoundMap = {};//object defined
for (var i = 0; i < str.length; i++) {
if(!charFoundMap[ str[i] ]) {
charFoundMap[ str[i] ]=1;
}
else
charFoundMap[ str[i] ] +=1;
//if object does not contain this
}
return charFoundMap;
}