Wörter in einer Zeichenfolge zählen

89

Ich habe versucht, Wörter in einem Text folgendermaßen zu zählen:

function WordCount(str) {
  var totalSoFar = 0;
  for (var i = 0; i < WordCount.length; i++)
    if (str(i) === " ") { // if a space is found in str
      totalSoFar = +1; // add 1 to total so far
  }
  totalsoFar += 1; // add 1 to totalsoFar to account for extra space since 1 space = 2 words
}

console.log(WordCount("Random String"));

Ich denke, ich habe das ziemlich gut verstanden, außer ich denke, dass die ifAussage falsch ist. Der Teil, der prüft, ob str(i)ein Leerzeichen enthalten ist, und 1 hinzufügt.

Bearbeiten:

Ich habe (dank Blender) herausgefunden, dass ich dies mit viel weniger Code tun kann:

function WordCount(str) { 
  return str.split(" ").length;
}

console.log(WordCount("hello world"));
Valerio Bozz
quelle
Wäre keine str.split(' ').lengtheinfachere Methode? jsfiddle.net/j08691/zUuzd
j08691
Oder str.split(' ')und dann diejenigen zählen, die keine Strings mit einer Länge von 0 sind?
Katie Kilian
7
string.split ('') .length funktioniert nicht. Leerzeichen sind nicht immer Wortgrenzen! Was ist, wenn zwischen zwei Wörtern mehr als ein Leerzeichen steht? Wie wäre es mit ". . ." ?
Aloso
Wie Aloso sagte, wird diese Methode nicht funktionieren.
Reality-Torrent
1
@ Reality-Torrent Dies ist ein alter Beitrag.
cst1992

Antworten:

104

Verwenden Sie eckige Klammern, keine Klammern:

str[i] === " "

Oder charAt:

str.charAt(i) === " "

Sie könnten es auch tun mit .split():

return str.split(' ').length;
Mixer
quelle
Ich glaube, ich habe verstanden, was Sie sagen. Sieht mein Code oben in der bearbeiteten Originalfrage in Ordnung aus?
Würde Ihre Lösung funktionieren, wenn die Wörter durch etwas anderes als das Leerzeichen begrenzt sind? Sprich durch Zeilenumbrüche oder Tabulatoren?
Nemesisfixx
7
@Blender gute Lösung, aber dies kann das falsche Ergebnis für doppelte Leerzeichen in einem String geben ..
ipalibowhyte
90

Probieren Sie diese aus, bevor Sie die Räder neu erfinden

from Anzahl der Wörter in einer Zeichenfolge mit JavaScript zählen

function countWords(str) {
  return str.trim().split(/\s+/).length;
}

von http://www.mediacollege.com/internet/javascript/text/count-words.html

function countWords(s){
    s = s.replace(/(^\s*)|(\s*$)/gi,"");//exclude  start and end white-space
    s = s.replace(/[ ]{2,}/gi," ");//2 or more space to 1
    s = s.replace(/\n /,"\n"); // exclude newline with a start spacing
    return s.split(' ').filter(function(str){return str!="";}).length;
    //return s.split(' ').filter(String).length; - this can also be used
}

von Verwenden Sie JavaScript, um Wörter in einer Zeichenfolge zu zählen, OHNE einen regulären Ausdruck zu verwenden - dies ist der beste Ansatz

function WordCount(str) {
     return str.split(' ')
            .filter(function(n) { return n != '' })
            .length;
}

Anmerkungen des Autors:

Sie können dieses Skript anpassen, um Wörter nach Belieben zu zählen. Der wichtige Teil ist s.split(' ').length- dies zählt die Räume. Das Skript versucht, alle zusätzlichen Leerzeichen (doppelte Leerzeichen usw.) vor dem Zählen zu entfernen. Wenn der Text zwei Wörter ohne Leerzeichen enthält, werden sie als ein Wort gezählt, z. B. "Erster Satz. Beginn des nächsten Satzes".

Einbauten
quelle
Ich habe diese Syntax einfach noch nie gesehen: s = s.replace (/ (^ \ s *) | (\ s * $) / gi, ""); s = s.replace (/ [] {2,} / gi, ""); s = s.replace (/ \ n /, "\ n"); Was bedeutet jede Zeile? Entschuldigung für die Bedürftigkeit
etwas? Dieser Code ist sehr verwirrend und die Website, die Sie buchstäblich kopiert und eingefügt haben, ist überhaupt nicht hilfreich. Ich bin nur mehr als alles andere verwirrt, dass es nach Wörtern ohne Leerzeichen suchen soll, aber wie? Nur eine Million zufällig platzierter Zeichen hilft wirklich nicht ...
Das ist schön, ich habe Sie nur gebeten, Ihren Code zu erklären, den Sie geschrieben haben. Ich habe die Syntax noch nie gesehen und wollte wissen, was sie bedeutet. Es ist in Ordnung, dass ich eine separate Frage gestellt habe und jemand meine Frage ausführlich beantwortet hat. Tut mir leid, dass ich so viel verlangt habe.
1
str.split (/ \ s + /). length funktioniert nicht so wie es ist: Nachgestellte Leerzeichen werden als ein anderes Wort behandelt.
Ian
2
Beachten Sie, dass für leere Eingaben 1 zurückgegeben wird.
pie6k
20

Eine weitere Möglichkeit, Wörter in einer Zeichenfolge zu zählen. Dieser Code zählt Wörter, die nur alphanumerische Zeichen und Zeichen "_", "'", "-", "'" enthalten.

function countWords(str) {
  var matches = str.match(/[\w\d\’\'-]+/gi);
  return matches ? matches.length : 0;
}
Alex
quelle
2
Könnte auch in Betracht ziehen, etwas hinzuzufügen, ’'-damit "Cat's meow" nicht als 3 Wörter zählt. Und "dazwischen"
mpen
@mpen danke für den Vorschlag. Ich habe meine Antwort entsprechend aktualisiert.
Alex
Das erste Zeichen in meiner Zeichenfolge ist ein rechts zitiertes FYI, kein Backtick :-D
mpen
1
Sie müssen nicht ’'in einem regulären Ausdruck entkommen . Verwenden Sie /[\w\d’'-]+/gi, um ESLint Warnungen vor unbrauchbarer Flucht zu vermeiden
Stefan Blamberg
18

Nach dem Bereinigen der Zeichenfolge können Sie Nicht-Leerzeichen oder Wortgrenzen abgleichen.

Hier sind zwei einfache reguläre Ausdrücke zum Erfassen von Wörtern in einer Zeichenfolge:

  • Folge von Nicht-Leerzeichen: /\S+/g
  • Gültige Zeichen zwischen Wortgrenzen: /\b[a-z\d]+\b/g

Das folgende Beispiel zeigt, wie die Wortanzahl mithilfe dieser Erfassungsmuster aus einer Zeichenfolge abgerufen wird.

/*Redirect console output to HTML.*/document.body.innerHTML='';console.log=function(s){document.body.innerHTML+=s+'\n';};
/*String format.*/String.format||(String.format=function(f){return function(a){return f.replace(/{(\d+)}/g,function(m,n){return"undefined"!=typeof a[n]?a[n]:m})}([].slice.call(arguments,1))});

// ^ IGNORE CODE ABOVE ^
//   =================

// Clean and match sub-strings in a string.
function extractSubstr(str, regexp) {
    return str.replace(/[^\w\s]|_/g, '')
        .replace(/\s+/g, ' ')
        .toLowerCase().match(regexp) || [];
}

// Find words by searching for sequences of non-whitespace characters.
function getWordsByNonWhiteSpace(str) {
    return extractSubstr(str, /\S+/g);
}

// Find words by searching for valid characters between word-boundaries.
function getWordsByWordBoundaries(str) {
    return extractSubstr(str, /\b[a-z\d]+\b/g);
}

// Example of usage.
var edisonQuote = "I have not failed. I've just found 10,000 ways that won't work.";
var words1 = getWordsByNonWhiteSpace(edisonQuote);
var words2 = getWordsByWordBoundaries(edisonQuote);

console.log(String.format('"{0}" - Thomas Edison\n\nWord count via:\n', edisonQuote));
console.log(String.format(' - non-white-space: ({0}) [{1}]', words1.length, words1.join(', ')));
console.log(String.format(' - word-boundaries: ({0}) [{1}]', words2.length, words2.join(', ')));
body { font-family: monospace; white-space: pre; font-size: 11px; }


Einzigartige Wörter finden

Sie können auch eine Zuordnung von Wörtern erstellen, um eindeutige Zählungen zu erhalten.

function cleanString(str) {
    return str.replace(/[^\w\s]|_/g, '')
        .replace(/\s+/g, ' ')
        .toLowerCase();
}

function extractSubstr(str, regexp) {
    return cleanString(str).match(regexp) || [];
}

function getWordsByNonWhiteSpace(str) {
    return extractSubstr(str, /\S+/g);
}

function getWordsByWordBoundaries(str) {
    return extractSubstr(str, /\b[a-z\d]+\b/g);
}

function wordMap(str) {
    return getWordsByWordBoundaries(str).reduce(function(map, word) {
        map[word] = (map[word] || 0) + 1;
        return map;
    }, {});
}

function mapToTuples(map) {
    return Object.keys(map).map(function(key) {
        return [ key, map[key] ];
    });
}

function mapToSortedTuples(map, sortFn, sortOrder) {
    return mapToTuples(map).sort(function(a, b) {
        return sortFn.call(undefined, a, b, sortOrder);
    });
}

function countWords(str) {
    return getWordsByWordBoundaries(str).length;
}

function wordFrequency(str) {
    return mapToSortedTuples(wordMap(str), function(a, b, order) {
        if (b[1] > a[1]) {
            return order[1] * -1;
        } else if (a[1] > b[1]) {
            return order[1] * 1;
        } else {
            return order[0] * (a[0] < b[0] ? -1 : (a[0] > b[0] ? 1 : 0));
        }
    }, [1, -1]);
}

function printTuples(tuples) {
    return tuples.map(function(tuple) {
        return padStr(tuple[0], ' ', 12, 1) + ' -> ' + tuple[1];
    }).join('\n');
}

function padStr(str, ch, width, dir) { 
    return (width <= str.length ? str : padStr(dir < 0 ? ch + str : str + ch, ch, width, dir)).substr(0, width);
}

function toTable(data, headers) {
    return $('<table>').append($('<thead>').append($('<tr>').append(headers.map(function(header) {
        return $('<th>').html(header);
    })))).append($('<tbody>').append(data.map(function(row) {
        return $('<tr>').append(row.map(function(cell) {
            return $('<td>').html(cell);
        }));
    })));
}

function addRowsBefore(table, data) {
    table.find('tbody').prepend(data.map(function(row) {
        return $('<tr>').append(row.map(function(cell) {
            return $('<td>').html(cell);
        }));
    }));
    return table;
}

$(function() {
    $('#countWordsBtn').on('click', function(e) {
        var str = $('#wordsTxtAra').val();
        var wordFreq = wordFrequency(str);
        var wordCount = countWords(str);
        var uniqueWords = wordFreq.length;
        var summaryData = [
            [ 'TOTAL', wordCount ],
            [ 'UNIQUE', uniqueWords ]
        ];
        var table = toTable(wordFreq, ['Word', 'Frequency']);
        addRowsBefore(table, summaryData);
        $('#wordFreq').html(table);
    });
});
table {
    border-collapse: collapse;
    table-layout: fixed;
    width: 200px;
    font-family: monospace;
}
thead {
    border-bottom: #000 3px double;;
}
table, td, th {
    border: #000 1px solid;
}
td, th {
    padding: 2px;
    width: 100px;
    overflow: hidden;
}

textarea, input[type="button"], table {
    margin: 4px;
    padding: 2px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>

<h1>Word Frequency</h1>
<textarea id="wordsTxtAra" cols="60" rows="8">Four score and seven years ago our fathers brought forth on this continent, a new nation, conceived in Liberty, and dedicated to the proposition that all men are created equal.

Now we are engaged in a great civil war, testing whether that nation, or any nation so conceived and so dedicated, can long endure. We are met on a great battle-field of that war. We have come to dedicate a portion of that field, as a final resting place for those who here gave their lives that that nation might live. It is altogether fitting and proper that we should do this.

But, in a larger sense, we can not dedicate -- we can not consecrate -- we can not hallow -- this ground. The brave men, living and dead, who struggled here, have consecrated it, far above our poor power to add or detract. The world will little note, nor long remember what we say here, but it can never forget what they did here. It is for us the living, rather, to be dedicated here to the unfinished work which they who fought here have thus far so nobly advanced. It is rather for us to be here dedicated to the great task remaining before us -- that from these honored dead we take increased devotion to that cause for which they gave the last full measure of devotion -- that we here highly resolve that these dead shall not have died in vain -- that this nation, under God, shall have a new birth of freedom -- and that government of the people, by the people, for the people, shall not perish from the earth.</textarea><br />
<input type="button" id="countWordsBtn" value="Count Words" />
<div id="wordFreq"></div>

Mr. Polywhirl
quelle
1
Dies ist eine großartige und umfassende Antwort. Vielen Dank für alle Beispiele, sie sind wirklich nützlich!
Connor
14

Ich denke, diese Methode ist mehr als Sie wollen

var getWordCount = function(v){
    var matches = v.match(/\S+/g) ;
    return matches?matches.length:0;
}
Sean
quelle
7

String.prototype.match Gibt ein Array zurück, können wir dann die Länge überprüfen.

Ich finde diese Methode am aussagekräftigsten

var str = 'one two three four five';

str.match(/\w+/g).length;
iamwhitebox
quelle
1
Möglicher Ort, an dem ein Fehler auftritt, wenn die Zeichenfolge leer ist
Purkhalo Alex,
5

Der einfachste Weg, den ich bisher gefunden habe, ist die Verwendung eines regulären Ausdrucks mit Split.

var calculate = function() {
  var string = document.getElementById('input').value;
  var length = string.split(/[^\s]+/).length - 1;
  document.getElementById('count').innerHTML = length;
};
<textarea id="input">My super text that does 7 words.</textarea>
<button onclick="calculate()">Calculate</button>
<span id="count">7</span> words

Tim
quelle
3

Die Antwort von @ 7-isnotbad ist extrem nah, zählt aber keine Einzelwortzeilen. Hier ist der Fix, der jede mögliche Kombination von Wörtern, Leerzeichen und Zeilenumbrüchen zu berücksichtigen scheint.

function countWords(s){
    s = s.replace(/\n/g,' '); // newlines to space
    s = s.replace(/(^\s*)|(\s*$)/gi,''); // remove spaces from start + end
    s = s.replace(/[ ]{2,}/gi,' '); // 2 or more spaces to 1
    return s.split(' ').length; 
}
neokio
quelle
3

Hier ist mein Ansatz, bei dem ein String einfach durch Leerzeichen geteilt wird, dann das Array für Schleifen und die Anzahl erhöht wird, wenn das Array [i] mit einem bestimmten Regex-Muster übereinstimmt.

    function wordCount(str) {
        var stringArray = str.split(' ');
        var count = 0;
        for (var i = 0; i < stringArray.length; i++) {
            var word = stringArray[i];
            if (/[A-Za-z]/.test(word)) {
                count++
            }
        }
        return count
    }

So aufgerufen:

var str = "testing strings here's a string --..  ? // ... random characters ,,, end of string";
wordCount(str)

(Zusätzliche Zeichen und Leerzeichen hinzugefügt, um die Genauigkeit der Funktion anzuzeigen)

Der obige Str gibt 10 zurück, was richtig ist!

user3743140
quelle
Einige Sprachen verwenden Sie nicht [A-Za-z]überhaupt
David
2

Es mag einen effizienteren Weg geben, dies zu tun, aber das hat bei mir funktioniert.

function countWords(passedString){
  passedString = passedString.replace(/(^\s*)|(\s*$)/gi, '');
  passedString = passedString.replace(/\s\s+/g, ' '); 
  passedString = passedString.replace(/,/g, ' ');  
  passedString = passedString.replace(/;/g, ' ');
  passedString = passedString.replace(/\//g, ' ');  
  passedString = passedString.replace(/\\/g, ' ');  
  passedString = passedString.replace(/{/g, ' ');
  passedString = passedString.replace(/}/g, ' ');
  passedString = passedString.replace(/\n/g, ' ');  
  passedString = passedString.replace(/\./g, ' '); 
  passedString = passedString.replace(/[\{\}]/g, ' ');
  passedString = passedString.replace(/[\(\)]/g, ' ');
  passedString = passedString.replace(/[[\]]/g, ' ');
  passedString = passedString.replace(/[ ]{2,}/gi, ' ');
  var countWordsBySpaces = passedString.split(' ').length; 
  return countWordsBySpaces;

}}

Es ist in der Lage, alle folgenden Wörter als separate Wörter zu erkennen:

abc,abc= 2 Wörter,
abc/abc/abc= 3 Wörter (funktioniert mit Schrägstrichen vorwärts und rückwärts),
abc.abc= 2 Wörter,
abc[abc]abc= 3 Wörter,
abc;abc= 2 Wörter,

(einige andere Vorschläge, die ich versucht habe, zählen jedes Beispiel oben als nur 1 x Wort) es auch:

  • ignoriert alle führenden und nachfolgenden Leerzeichen

  • zählt einen einzelnen Buchstaben gefolgt von einer neuen Zeile als Wort - was ich festgestellt habe, dass einige der auf dieser Seite gegebenen Vorschläge nicht zählen, zum Beispiel:
    a
    a
    a
    a
    a wird
    manchmal als 0 x Wörter gezählt, und andere Funktionen zählen es nur als 1 x Wort anstelle von 5 x Wörtern)

Wenn jemand Ideen hat, wie man es verbessern oder sauberer / effizienter machen kann, dann addieren Sie bitte 2 Cent! Hoffe das hilft jemandem raus.

Wender
quelle
2
function countWords(str) {
    var regEx = /([^\u0000-\u007F]|\w)+/g;  
    return str.match(regEx).length;
}

Erläuterung:

/([^\u0000-\u007F]|\w)passt zu Wortzeichen - was großartig ist -> Regex erledigt das schwere Heben für uns. (Dieses Muster basiert auf der folgenden SO-Antwort: https://stackoverflow.com/a/35743562/1806956 von @Landeeyo)

+ Entspricht der gesamten Zeichenfolge der zuvor angegebenen Wortzeichen. Daher gruppieren wir Wortzeichen grundsätzlich.

/g bedeutet, dass es bis zum Ende sucht.

str.match(regEx) gibt ein Array der gefundenen Wörter zurück - also zählen wir seine Länge.

Ronen Rabinovici
quelle
1
Komplizierter Regex ist die Kunst der Hexerei. Ein Zauber, den wir aussprechen lernen, aber niemals den Mut haben, nach dem Warum zu fragen. Ich danke Ihnen für das Teilen.
Blaise
^ das ist ein fantastisches Zitat
r3wt
Ich erhalte folgende
Aliton Oliveira
Diese Regex wird einen Fehler auslösen, wenn die Zeichenfolge mit / oder (
Walter Monecke
@WalterMonecke hat es gerade auf Chrom getestet - habe den Fehler nicht bekommen. Woher hast du einen Fehler dabei? Danke
Ronen Rabinovici
2

Für diejenigen, die Lodash verwenden möchten, kann die _.wordsFunktion verwendet werden:

var str = "Random String";
var wordCount = _.size(_.words(str));
console.log(wordCount);
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.11/lodash.min.js"></script>

Penny Liu
quelle
2

Dies behandelt alle Fälle und ist so effizient wie möglich. (Sie möchten keine Aufteilung (''), es sei denn, Sie wissen vorher, dass es keine Leerzeichen mit einer Länge von mehr als einem gibt.):

var quote = `Of all the talents bestowed upon men, 
              none is so precious as the gift of oratory. 
              He who enjoys it wields a power more durable than that of a great king. 
              He is an independent force in the world. 
              Abandoned by his party, betrayed by his friends, stripped of his offices, 
              whoever can command this power is still formidable.`;

function WordCount(text) {
    text = text.trim();
    return text.length > 0 ? text.split(/\s+/).length : 0;
}
console.log(WordCount(quote));//59
console.log(WordCount('f'));//1
console.log(WordCount('  f '));//1
console.log(WordCount('   '));//0
WesleyAC
quelle
1

Hier ist eine Funktion, die die Anzahl der Wörter in einem HTML-Code zählt:

$(this).val()
    .replace(/((&nbsp;)|(<[^>]*>))+/g, '') // remove html spaces and tags
    .replace(/\s+/g, ' ') // merge multiple spaces into one
    .trim() // trim ending and beginning spaces (yes, this is needed)
    .match(/\s/g) // find all spaces by regex
    .length // get amount of matches
Riki137
quelle
1
let leng = yourString.split(' ').filter(a => a.trim().length > 0).length
Tim
quelle
6
Während dieses Code-Snippet die Frage lösen kann, hilft eine Erklärung wirklich dabei, die Qualität Ihres Beitrags zu verbessern. Denken Sie daran, dass Sie die Frage für Leser in Zukunft beantworten und diese Personen möglicherweise die Gründe für Ihren Codevorschlag nicht kennen.
Isma
1

Ich bin mir nicht sicher, ob dies zuvor gesagt wurde oder ob es das ist, was hier benötigt wird, aber konnten Sie die Zeichenfolge nicht zu einem Array machen und dann die Länge finden?

let randomString = "Random String";

let stringWords = randomString.split(' ');
console.log(stringWords.length);
brianna124
quelle
1

Ich denke, diese Antwort bietet alle Lösungen für:

  1. Anzahl der Zeichen in einer bestimmten Zeichenfolge
  2. Anzahl der Wörter in einer bestimmten Zeichenfolge
  3. Anzahl der Zeilen in einer bestimmten Zeichenfolge

 function NumberOf() { 
		 var string = "Write a piece of code in any language of your choice that computes the total number of characters, words and lines in a given text. \n This is second line. \n This is third line.";

		 var length = string.length; //No of characters
		 var words = string.match(/\w+/g).length; //No of words
		 var lines = string.split(/\r\n|\r|\n/).length; // No of lines

		 console.log('Number of characters:',length);
		 console.log('Number of words:',words);
		 console.log('Number of lines:',lines);


}

NumberOf();

  1. Zuerst müssen Sie die Länge der angegebenen Zeichenfolge anhand ermitteln string.length
  2. Dann können Sie die Anzahl der Wörter finden, indem Sie sie mit einer Zeichenfolge abgleichen string.match(/\w+/g).length
  3. Schließlich können Sie jede Zeile so teilen string.length(/\r\n|\r|\n/).length

Ich hoffe, dies kann denen helfen, die nach diesen 3 Antworten suchen.

LiN
quelle
1
Ausgezeichnet. Bitte ändern Sie den Variablennamen stringin etwas anderes. Es ist verwirrend. Ich habe eine Sekunde lang nachgedacht, dass dies string.match()eine statische Methode ist. Prost.
Schüchterner Agam
Ja!! sicher. @ ShyAgam
LiN
1

Genauigkeit ist auch wichtig.

Option 3 ersetzt im Grunde alle Leerzeichen bis auf Leerzeichen durch a +1und wertet diese dann aus, um die Anzahl 1der Wörter zu zählen.

Es ist die genaueste und schnellste Methode der vier, die ich hier gemacht habe.

Bitte beachten Sie, dass es langsamer als ist, return str.split(" ").length;aber im Vergleich zu Microsoft Word genau ist.

Siehe Datei ops / s und Anzahl der zurückgegebenen Wörter unten.

Hier ist ein Link, um diesen Test durchzuführen. https://jsbench.me/ztk2t3q3w5/1

// This is the fastest at 111,037 ops/s ±2.86% fastest
var str = "All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy.";
function WordCount(str) {
  return str.split(" ").length;
}
console.log(WordCount(str));
// Returns 241 words. Not the same as Microsoft Word count, of by one.

// This is the 2nd fastest at 46,835 ops/s ±1.76% 57.82% slower
var str = "All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy.";
function WordCount(str) {
  return str.split(/(?!\W)\S+/).length;
}
console.log(WordCount(str));
// Returns 241 words. Not the same as Microsoft Word count, of by one.

// This is the 3rd fastest at 37,121 ops/s ±1.18% 66.57% slower
var str = "All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy.";
function countWords(str) {
  var str = str.replace(/\S+/g,"\+1");
  return eval(str);
}
console.log(countWords(str));
// Returns 240 words. Same as Microsoft Word count.

// This is the slowest at 89 ops/s 17,270 ops/s ±2.29% 84.45% slower
var str = "All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy. All work and no play makes Jack a dull boy.";
function countWords(str) {
  var str = str.replace(/(?!\W)\S+/g,"1").replace(/\s*/g,"");
  return str.lastIndexOf("");
}
console.log(countWords(str));
// Returns 240 words. Same as Microsoft Word count.

Ste
quelle
1
function WordCount(str) {
    var totalSoFar = 0;
    for (var i = 1; i < str.length; i++) {
        if (str[i] === " ") {
            totalSoFar ++;
        }
    }
    return totalSoFar; 
}
console.log(WordCount("hi my name is raj));
Raj Chandak
quelle
2
Nur-Code-Antworten werden auf dieser Website im Allgemeinen verpönt. Könnten Sie bitte Ihre Antwort bearbeiten, um einige Kommentare oder Erklärungen zu Ihrem Code aufzunehmen? Erklärungen sollten Fragen beantworten wie: Was macht es? Wie macht es das? Wo geht es hin? Wie löst es das Problem von OP? Siehe: Antworten . Vielen Dank!
Eduardo Baitello
0
<textarea name="myMessage" onkeyup="wordcount(this.value)"></textarea>
<script type="text/javascript">
var cnt;
function wordcount(count) {
var words = count.split(/\s/);
cnt = words.length;
var ele = document.getElementById('w_count');
ele.value = cnt;
}
document.write("<input type=text id=w_count size=4 readonly>");
</script>
Sk Mourya
quelle
0

Ich weiß, dass es spät ist, aber dieser reguläre Ausdruck sollte Ihr Problem lösen. Dies stimmt überein und gibt die Anzahl der Wörter in Ihrer Zeichenfolge zurück. Eher als die, die Sie als Lösung markiert haben, die Raum-Raum-Wort als 2 Wörter zählt, obwohl es wirklich nur 1 Wort ist.

function countWords(str) {
    var matches = str.match(/\S+/g);
    return matches ? matches.length : 0;
}
Reality-Torrent
quelle
0

Sie haben einige Fehler in Ihrem Code.

function WordCount(str) {
    var totalSoFar = 0;
    for (var i = 0; i < str.length; i++) {
        if (str[i] === " ") {
            totalSoFar += 1;
        }
    }
    return totalSoFar + 1; // you need to return something.
}
console.log(WordCount("Random String"));

Es gibt noch einen anderen einfachen Weg, reguläre Ausdrücke zu verwenden:

(text.split(/\b/).length - 1) / 2

Der genaue Wert kann sich um 1 Wort unterscheiden, zählt aber auch Wortränder ohne Leerzeichen, zum Beispiel "word-word.word". Und es werden keine Wörter gezählt, die keine Buchstaben oder Zahlen enthalten.

Aloso
quelle
0
function totalWordCount() {
  var str ="My life is happy"
  var totalSoFar = 0;

  for (var i = 0; i < str.length; i++)
    if (str[i] === " ") { 
     totalSoFar = totalSoFar+1;
  }
  totalSoFar = totalSoFar+ 1; 
  return totalSoFar
}

console.log(totalWordCount());
Piyusha Patel
quelle
Bitte fügen Sie einige Erklärungen hinzu, die Ihre Antwort bearbeiten. Vermeiden Sie nur Code-Antworten
GGO