zliczanie częstotliwości znaków w ciągu znaków przy użyciu javascript

Question

Potrzebuję napisać jakąś pętlę, która może zliczyć częstotliwość każdej litery w ciągu.

Na przykład: "aabsssd"

wyjście: A: 2 B: 1, s: 3, d: 1

też chcą map sam charakter jak nazwy właściwości w obiekcie. Jakiś dobry pomysł, jak to zrobić?

Nie jestem pewien, jak to zrobić.

To gdzie ja jestem tak daleko:

var arr = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]; 

function counter(x) { 
    var count=0, temp = []; 
    x = x.split(''); 
    console.log(x); 
    for(var i=0, len = x.length; i < len; i++) { 
     if(x[i] == "a") { 
      count++; 
     } 
    } 
    return count; 
} 
var a = "aabbddd"; 
console.log(counter(a)); 

Answer 1

Proszę bardzo:

function getFrequency(string) { 
    var freq = {}; 
    for (var i=0; i<string.length;i++) { 
     var character = string.charAt(i); 
     if (freq[character]) { 
      freq[character]++; 
     } else { 
      freq[character] = 1; 
     } 
    } 

    return freq; 
}; 

Answer 2

Oto kolejna opcja korzystania underscore.js:

function charCount(str) { 
    return _(str.split('')).countBy(function(char) { 
     return char.toLowerCase(); 
    }); 
} 

charCount('aaabbbbdd') wyjść Object {a: 3, b: 4, d: 2}

Answer 3

for(i = strlen(string)var string = 'aabsssd'; 
var chars = new Array(); 
for(var i = 0; i < string.length; i++){ 
    var char = string.charAt(i); 
    if(chars[char] == undefined){ 
     chars[char] = 0; 
    } 
    chars[char]++; 
} 
console.log(chars); 

Answer 4

Innym rozwiązaniem:

function count (string) { 
    var count = {}; 
    string.split('').forEach(function(s) { 
    count[s] ? count[s]++ : count[s] = 1; 
    }); 
    return count; 
} 

Answer 5

Więcej deklaratywny sposób, aby histogram słowo będzie wykorzystać do zmniejszenia iterację liter i pochodzą z nowego obiektu, który zawiera litery jak klucze i częstotliwości jako wartości.

function getFrequency(str) { 
 
    return str.split('').reduce((prev, curr) => { 
 
    prev[curr] = prev[curr] ? prev[curr] + 1 : 1; 
 
    return prev; 
 
    }, {}); 
 
}; 
 

 
console.log(getFrequency('test')); // => {t: 2, e: 1, s: 1}

Answer 6

niektóre ES6 składnia ze zmniejszenia:

let counter = str => { 
    return str.split('').reduce((total, letter) => { 
    total[letter] ? total[letter]++ : total[letter] = 1; 
    return total; 
    }, {}); 
}; 

counter("aabsssd"); // => { a: 2, b: 1, s: 3, d: 1 } 

Answer 7

const recorrences = ['a', 'b', 'c', 'a', 'b','a'] 
 
       .map(i => !!~i.indexOf('a')) 
 
       .filter(i => i) 
 
       .length; 
 
console.log(`recorrences ${recorrences}`) 
 
//recorrences 3

Answer 8

Oto kolejny sposób:

function freqMap(s) { 
    freq={}; 
    for (var c of s) 
     freq[c]=-~freq[c]; 
    return freq; 
} 

np. freqMap ("MaMaMia") zwraca Object {M: 3, a: 3, i: 1}

Ta metoda wykorzystuje fakt, że w javascriptach, bitowe nie w "niezdefiniowanym" daje -1, (podczas gdy "undefined + 1 "daje NaN). Tak więc - ~ undefined to 1, - ~ 1 to 2, - ~ 2 to 3 itd.

Możemy w ten sposób powtórzyć ciąg znaków i po prostu zwiększyć częstotliwość [c] bez żadnego "jeśli". Gdy po raz pierwszy napotkamy znak c, freq [c] będzie niezdefiniowany, więc ustawiamy go na - ~ freq [c], który jest 1. Jeśli później ponownie napotkamy c, ponownie ustawiamy freq [c] na - ~ freq [c], które teraz będzie 2 itd.

Prosty, elegancki, zwięzły.