Wort-Frequenz in javascript

Wie kann ich das implementieren javascript-Funktion zum berechnen der Häufigkeit der jedes Wort in einem bestimmten Satz.

dies ist mein code:

function search () {
  var data = document.getElementById('txt').value;
  var temp = data;
  var words = new Array();
  words = temp.split(" ");
  var uniqueWords = new Array();
  var count = new Array();


  for (var i = 0; i < words.length; i++) {
    //var count=0;
    var f = 0;
    for (j = 0; j < uniqueWords.length; j++) {
      if (words[i] == uniqueWords[j]) {
        count[j] = count[j] + 1;
        //uniqueWords[j]=words[i];
        f = 1;
      }
    }
    if (f == 0) {
      count[i] = 1;
      uniqueWords[i] = words[i];
    }
    console.log("count of " + uniqueWords[i] + " - " + count[i]);
  }
}

bin nicht in der Lage zu verfolgen, das problem ..jede Hilfe ist sehr appriciated.
Ausgabe in diesem format:
Anzahl der is - 1
die Anzahl der - 2..

input: dies ist anil ist kum der anil

Wie sollen wir wissen, dass es auch ein problem mit diesem code?
leider habe ich den screenshot Hinzugefügt
Literale: var words = [] statt var words = new Array()

InformationsquelleAutor Anil | 2015-06-18

javascript

14

Ich das Gefühl haben über-komplizierte Dinge, indem mehrere arrays, strings und sich häufigen (und schwer zu Folgen) Kontext-Wechsel zwischen Schleifen und verschachtelte Schleifen.

Unten ist der Ansatz, den ich möchte Sie ermutigen, in Betracht ziehen. Ich habe inline-Kommentare, um zu erklären, jeden Schritt entlang der Weise. Ist dies unklar ist, bitte lassen Sie mich wissen in den Kommentaren und ich werde überdenken, um die Verständlichkeit zu erhöhen.
```
(function () {

    /* Below is a regular expression that finds alphanumeric characters
       Next is a string that could easily be replaced with a reference to a form control
       Lastly, we have an array that will hold any words matching our pattern */
    var pattern = /\w+/g,
        string = "I I am am am yes yes.",
        matchedWords = string.match( pattern );

    /* The Array.prototype.reduce method assists us in producing a single value from an
       array. In this case, we're going to use it to output an object with results. */
    var counts = matchedWords.reduce(function ( stats, word ) {

        /* `stats` is the object that we'll be building up over time.
           `word` is each individual entry in the `matchedWords` array */
        if ( stats.hasOwnProperty( word ) ) {
            /* `stats` already has an entry for the current `word`.
               As a result, let's increment the count for that `word`. */
            stats[ word ] = stats[ word ] + 1;
        } else {
            /* `stats` does not yet have an entry for the current `word`.
               As a result, let's add a new entry, and set count to 1. */
            stats[ word ] = 1;
        }

        /* Because we are building up `stats` over numerous iterations,
           we need to return it for the next pass to modify it. */
        return stats;

    }, {} );

    /* Now that `counts` has our object, we can log it. */
    console.log( counts );

}());
```
- Warum setzen alle Logik im Gegenzug statememt, wenn Ihr nicht einmal zurückgegeben. Ich denke, es macht den code schwerer zu Lesen, zu verwalten und zu verstehen ist.
- Weil ich mag die ästhetik der Verwendung einer einzelnen Zeile ein; und es ist kurz genug, dass Sie sehen können words zurückgegeben wird letztendlich. Wenn Sie lieber zwei Linien, zwei Linien verwenden 😉
- Ich verstehe, dass aber das schreiben von code sollte writtwn, so dass Sie oder eine andere person kann leicht verstehen, es später auf sechs Monate. Einzeiler sind gut, wenn Sie verbessern das Verständnis von nicht verursacht Ablenkung von der eigentlichen Logik... aber hier ist es einfach zu verpassen, die letzten Komma ... wenn es nur Lesen, es liest sich komisch "return abc, d", nur d wird zurückgegeben
- Vielen Dank für die Lösung , aber bin neu in javascript und es braucht Zeit, um zu verstehen, ur-code. kann u bitte helfen Sie mir herauszufinden, die Fehler in meinem code, da habe ich viel Zeit zu schreiben, den oben genannten code .
- Ich kann Sie verstehen, und Stimmen im Prinzip.
- Der Ansatz, den Sie nahmen umfasst Satzzeichen mit Worten, erfordert mehrere arrays, und zu viel Kontext-switching. Anstatt zu versuchen, um diesen Ansatz besser zu arbeiten, möchte ich Sie dazu ermutigen, neu zu überdenken, das problem vollständig.
- Vielen Dank für Ihren Vorschlag. ich werde versuchen, Ihren code besser nachvollziehen und umsetzen . noch einmal vielen Dank.
- Ich habe umgeschrieben, die Antwort, Sie nehmen Ihren Rat zu Herzen.
- gut erklärt .. danke dafür, dass es so klar und einfach zu verstehen. vielen Dank für deine Bemühungen..!!
- Bitte beachten Sie: reduzieren Sie wird nicht unterstützt in IE 8 und unten.
- Richtig, aber MDN hat ein polyfill.
- Was passiert, wenn der text-Inhalt ist "ich ich bin bin bin ja ja-Konstruktor ." Gibt es eine nicht-langweilige Art und Weise des Umgangs mit dieser in JS?
- wie würden Sie einen filter setzen, um nur zurück, Worte, die scheinen, mehr als oder weniger als eine bestimmte Anzahl von Zeiten nur? Danke!
- Ich würde ändern das Muster zu -?\w[\w'’-]* zu erkennen mehr Wörter (Apparate, zusammengesetzte Adjektive, "ol'", etc.).
InformationsquelleAutor Sampson
12

Hier ist eine JavaScript-Funktion, um die Häufigkeit der jedes Wort in einem Satz:
```
function wordFreq(string) {
    var words = string.replace(/[.]/g, '').split(/\s/);
    var freqMap = {};
    words.forEach(function(w) {
        if (!freqMap[w]) {
            freqMap[w] = 0;
        }
        freqMap[w] += 1;
    });

    return freqMap;
}
```
Wird es wieder ein hash von Wort zu Wort zählen. So zum Beispiel, wenn wir es so:
```
console.log(wordFreq("I am the big the big bull."));
> Object {I: 1, am: 1, the: 2, big: 2, bull: 1}
```
Können Sie iterieren Sie über die Worte mit Object.keys(result).sort().forEach(result) {...}. So konnten wir Haken, dass bis etwa so:
```
var freq = wordFreq("I am the big the big bull.");
Object.keys(freq).sort().forEach(function(word) {
    console.log("count of " + word + " is " + freq[word]);
});
```
Denen ausgeben würde:
```
count of I is 1
count of am is 1
count of big is 2
count of bull is 1
count of the is 2
```
JSFiddle: http://jsfiddle.net/ah6wsbs6/

Und hier ist wordFreq Funktion im ES6:
```
function wordFreq(string) {
  return string.replace(/[.]/g, '')
    .split(/\s/)
    .reduce((map, word) =>
      Object.assign(map, {
        [word]: (map[word])
          ? map[word] + 1
          : 1,
      }),
      {}
    );
}
```
JSFiddle: http://jsfiddle.net/r1Lo79us/
- Vielen Dank für die Lösung . ich versuche zu verstehen, Ihr code, und ich werde versuchen es zu implementieren . aber kann u bitte darauf hinweisen, den Fehler in meinem code?
- Erste Fehler ist zu versuchen zu zählen, arbeitet, indem Dinge, die in der Reihe. Es ist viel einfacher, zu zählen über einen hash. In JavaScript ein Objekt oder {} ist wie ein hash-nutzen Sie also die einfachsten Dinge nutzen. Ich werde schauen.
- Ja, ich habe versucht, aber ich würde am Ende schreiben Sie es auf dasselbe wie oben.
- Ja, ich habe zwei arrays nur klar zu sein, und da wusste ich nicht viel über die map-Objekt. ich werde versuchen, in Objekte Konzept .. danke
- Es ist viel viel schwieriger, die Verwendung von mehreren arrays. Sie können es tun, aber es ist viel zu viel Arbeit. Gute Idee zu lernen, über hashes ersten.
- ich werde versuchen zu lernen, über hashes .. danke nochmals
InformationsquelleAutor Cymen
0

Hier ist eine aktualisierte version von Ihrem eigenen code...
```
<!DOCTYPE html>
<html>
<head>
<title>string frequency</title>
<style type="text/css">
#text{
    width:250px;
}
</style>
</head>

<body >

<textarea id="txt" cols="25" rows="3" placeholder="add your text here">   </textarea></br>
<button type="button" onclick="search()">search</button>

    <script >

        function search()
        {
            var data=document.getElementById('txt').value;
            var temp=data;
            var words=new Array();
            words=temp.split(" ");

            var unique = {};


            for (var i = 0; i < words.length; i++) {
                var word = words[i];
                console.log(word);

                if (word in unique)
                {
                    console.log("word found");
                    var count  = unique[word];
                    count ++;
                    unique[word]=count;
                }
                else
                {
                    console.log("word NOT found");
                    unique[word]=1;
                }
            }
            console.log(unique);
        }

    </script>

</body>
```
Ich denke, deine Schleife war zu kompliziert. Auch, versuchen, zu produzieren der letzten Zählung noch dabei Ihre ersten Durchlauf das array der Wörter ist zum scheitern verurteilt, weil Sie können nicht testen für Einzigartigkeit, bis Sie überprüft haben, jedes Wort im array.

Anstatt alle Zähler, ich habe ein Javascript-Objekt zu arbeiten, wie ein assoziatives array, so können wir speichern jede eindeutige Wort, und das zählen, wie oft es Auftritt.

Dann, sobald wir beenden die Schleife, können wir das endgültige Ergebnis zu sehen.

Auch diese Lösung nutzt auch kein regex 😉

Werde ich auch hinzufügen, dass es sehr schwer für die Anzahl der Wörter nur auf Leerzeichen. In diesem code "eins, zwei, eins" werden die Ergebnisse in "eins" und "eins" als verschiedene, eindeutige Worte.
- dies funktioniert gut und einfach zu verstehen für einen Neuling wie mich .. vielen Dank .
- Durch die Aufteilung auf Räume, "Diese Welt ist deine Welt." würde behandeln "Welt" und "Welt". als zwei verschiedene Wörter. Auch JavaScript nicht assoziative arrays, also nicht erwarten, dass Objekte, Verhalten sich wie Sie. Die in Betreiber ist gefährlich, hier zu verwenden, wie es enthält Eigenschaften über die Prototyp-Kette. Also, wenn Sie Ihre Zeichenkette hat Wörter wie "Länge" in Ihnen, Sie erhalten irreführende Ergebnisse. Schließlich, "keine regex" ist nicht unbedingt eine gute oder erlösende Qualität einer Lösung. Reguläre Ausdrücke sind ein leistungsfähiges Dienstprogramm, die stärken jeder Entwickler, der investiert die Zeit, um Sie zu verstehen 🙂
- hi @JonathanSampson . Ich willige ein, dass die regex sind mächtig. Es ist nur so, dass der OP wollte ein Update für Ihren code, und anstatt bieten eine ganz andere Lösung basiert auf der regex, ich habe versucht, ändern Sie die original-code. Ich glaube, regex hat auch ein "Wort" operator ist, könnte auch lösen die "Worte brechen auf "white space" - Problem, so dass regex könnte eine gute Lösung für dieses problem. Für den operator "in", ich muss in diesem Blick. Ich wusste es nicht, war problematisch.
- Deine Antwort ist nicht schlecht, wir sind alle am lernen 🙂
InformationsquelleAutor Lucien Stals

Während beide von den Antworten hier richtig sind, vielleicht sind die besser, aber keiner von Ihnen Anschrift OP ' s Frage (was ist falsch mit dem sein code).

Das problem mit den OP ' s code ist hier:

if(f==0){
    count[i]=1;
    uniqueWords[i]=words[i];
}

Auf jedes neue Wort (unique word) den code, fügt es zu uniqueWords im index, an dem das Wort war in words. Daher gibt es Lücken in uniqueWords array. Dies ist der Grund, warum einige undefined Werte.

Drucken uniqueWords. Es sollte etwas geben wie:

["dies", "ist", "anil", 4: "kum", 5: "die"]

Hinweis: es gibt kein element für index 3.

Auch der Druck der letzten Zählung sollte nach der Verarbeitung aller Wörter in der words array.

Hier die korrigierte version:

function search()
{
    var data=document.getElementById('txt').value;
    var temp=data;
    var words=new Array();
    words=temp.split(" ");
    var uniqueWords=new Array();
    var count=new Array();


    for (var i = 0; i < words.length; i++) {
        //var count=0;
        var f=0;
        for(j=0;j<uniqueWords.length;j++){
            if(words[i]==uniqueWords[j]){
                count[j]=count[j]+1;
                //uniqueWords[j]=words[i];
                f=1;
            }
        }
        if(f==0){
            count[i]=1;
            uniqueWords[i]=words[i];
        }
    }
    for ( i = 0; i < uniqueWords.length; i++) {
        if (typeof uniqueWords[i] !== 'undefined')
            console.log("count of "+uniqueWords[i]+" - "+count[i]);       
    }
}

Habe ich nur verschoben, der Druck des Grafen aus der Verarbeitung der Schleife in eine neue Schleife, und fügte hinzu, eine if not undefined überprüfen.

Fiddle: https://jsfiddle.net/cdLgaq3a/

InformationsquelleAutor Anurag Peshne

-1

Ich würde mich mit Sampson match-senken-Methode für etwas bessere Effizienz. Hier ist eine modifizierte version, die mehr Produktion-bereit. Es ist nicht perfekt, aber es sollte sich auf die überwiegende Mehrheit der Szenarien (z.B. "gut genug").

function calcWordFreq(s) {
  //Normalize
  s = s.toLowerCase();
  //Strip quotes and brackets
  s = s.replace(/["“”(\[{}\])]|\B['‘]([^'’]+)['’]/g, '$1');
  //Strip dashes and ellipses
  s = s.replace(/[‒–—―…]|--|\.\.\./g, ' ');
  //Strip punctuation marks
  s = s.replace(/[!?;:.,]\B/g, '');
  return s.match(/\S+/g).reduce(function(oFreq, sWord) {
    if (oFreq.hasOwnProperty(sWord)) ++oFreq[sWord];
    else oFreq[sWord] = 1;
    return oFreq;
  }, {});
}

calcWordFreq('A ‘bad’, “BAD” wolf-man...a good ol\' spook -- I\'m frightened!') gibt

{
  "a": 2
  "bad": 2
  "frightened": 1
  "good": 1
  "i'm": 1
  "ol'": 1
  "spook": 1
  "wolf-man": 1
}

InformationsquelleAutor thdoan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.