J'essaie de compter les lettres dans un texte et d'obtenir un objet pour afficher le nombre de lettres pour chaque mot.

Ainsi, pour l'entrée "Argument here", la sortie attendue serait:

{ Argument: { A: 1, r: 2, g: 1, u: 1, m: 1, e: 3, n: 1, t: 1, ' ': 1, h: 1 },
  here: { e: 2, h: 1, r: 1} }

Ma tentative:

function LetterCountI(str) { 
 var arr = str.split(" "); var cCount = {}; var anotherO = {}; var final = {};
for(var i = 0; i < arr.length; i++){
    if(cCount[arr[i]]){
        cCount[arr[i]]++;
    } else {
        cCount[arr[i]] = 1;
    }
}        

var letterCount = str.split("");
 for(var j = 0; j < letterCount.length; j++){

    if(anotherO[letterCount[j]]){
        anotherO[letterCount[j]]++;
    } else {
        anotherO[letterCount[j]] = 1;
    }
    }

for(var property in cCount){
  final[property] = anotherO;
}

return final;

}

LetterCountI("Argument here");

Ce que je reçois actuellement est

{ Argument: { A: 1, r: 2, g: 1, u: 1, m: 1, e: 3, n: 1, t: 1, ' ': 1, h: 1 },
  here: { A: 1, r: 2, g: 1, u: 1, m: 1, e: 3, n: 1, t: 1, ' ': 1, h: 1 } }
2
spaceDog 5 mars 2016 à 07:59

3 réponses

Meilleure réponse

Tout d'abord, votre approche peut échouer . Si votre texte juste pour le plaisir contient __proto__ ou une autre propriété Object, cette propriété vous donnera une erreur / un résultat inattendu. Quoi qu'il en soit, si vous êtes toujours sûr de vouloir utiliser cette méthode au lieu de cartes de hachage, vous pouvez continuer avec les solutions ci-dessous.

Si vous souhaitez une méthode plus rapide, vous pouvez utiliser le code suivant:

function count(string) {
  var tmpname = '', tmpvalue = {}, result = {}, i = string.length;

  while (i--) {
    var letter = string[i];

    if (letter === ' ') {
      result[tmpname] = tmpvalue;
      tmpname = '';
      tmpvalue = {};
    }
    else {
      tmpname = letter + tmpname;
      tmpvalue[letter] = (tmpvalue[letter] || 0) + 1;
    }
  }

  if (tmpname) {
    result[tmpname] = tmpvalue;
  }

  return result;
}

console.log(count("Argument here"));

Ceci n'appelle pas la fonction split, donc c'est théoriquement plus rapide que la solution de Max Mastalerz qui fait au moins 2 boucles complètes en appelant une fonction split deux fois. Si vous ne vous souciez pas vraiment des performances ou si vos textes sont généralement très courts, vous pouvez utiliser une version un peu plus courte de la solution de Max Mastalerz pour aborder ceci:

function count(string) {
  return string.split(' ').reduce(function(a, b) {
    b.split('').reduce(function(c, d) {
      return (c[d] = (c[d] || 0) + 1 , c);
    }, a[b] = {});

    return a;
  }, {});
}

console.log(count("Argument here"));

Il fait exactement la même chose, en trouvant d'abord les mots puis en trouvant les lettres de chaque mot.

1
smnbbrv 5 mars 2016 à 06:31

JSFiddle, les éléments suivants compteront les lettres des mots qui composent une chaîne:

function letterCounts(s) {
    var result = {};

    s.split(' ').forEach(function(e) {
        result[e] = {};
        e.split('').forEach(function(c) {
            if(!result[e][c]) { result[e][c]=0; }
            result[e][c]++;
        });
    });

    return result;
}

letterCounts('Argument Here');

Le résultat est:

"{"Argument":{"A":1,"r":1,"g":1,"u":1,"m":1,"e":1,"n":1,"t":1},"Here":{"H":1,"e":2,"r":1}}"

enter image description here

3
Max 5 mars 2016 à 05:56

Utiliser forEach est une méthode plus simple, mais voici quelque chose d'un peu plus vanillé:

function countLetters(string) {
var obj = {};
var arr = string.split(' ');
for (var i = 0; i < arr.length; i++) {
  obj[arr[i]] = {};
  for (var j = 0; j < arr[i].length; j++) {
   if (!obj[arr[i]][arr[i][j]]) {
    obj[arr[i]][arr[i][j]] = 1;
   } else {
    obj[arr[i]][arr[i][j]]++;
  }
}
} return obj;
}



console.log(countLetters("Argument here"));
0
mrmaclean89 27 sept. 2017 à 17:32