it-swarm.com.de

Javascript: Das längste Wort in einem String finden

function longestWord(string) {
    var str = string.split(" ");
    var longest = 0;
    var Word = null;
    for (var i = 0; i < str.length - 1; i++) {
        if (longest < str[i].length) {
            longest = str[i].length;
            Word = str[i];
        }
    }
    return Word;
}

Wenn ich longestWord("Pride and Prejudice") anrufe, wird 'Pride' und nicht 'Prejudice' zurückgegeben. Dies ist das längste Wort ... warum? Ich habe einige ähnliche Fragen geprüft, aber die Lösungen sahen meinem Code sehr ähnlich.

12
bard

Das liegt daran, dass Sie nicht alle Elemente im Array vergleichen, sondern das letzte Element weglassen.

for (var i = 0; i < str.length - 1; i++)

sollte sein

for (var i = 0; i < str.length; i++)

oder

for (var i = 0; i <= str.length - 1; i++)
16
Musa

Ein funktionaler Ansatz für solche Probleme besteht darin, dass Sie nicht einmal zählen müssen:

function longer(champ, contender) {
  return (contender.length > champ.length) ? contender: champ;
}

function longestWord(str) {
    var words = str.split(' ');
    return words.reduce(longer);
}

Siehe MDN Array.reduce für weitere Informationen. (Hinweis: reduce benötigt eine Unterlage für IE8)

9
merv

Sie haben einen -1 in Ihrem Zustand, es scannt ihn niemals:

for (var i = 0; i < str.length - 1; i++) {

Sollte sein:

for (var i = 0; i < str.length; i++) {

Demo: http://jsfiddle.net/LfgFk/

4
tymeJV

Hier ist Ihre Lösung mit einem forEach. Dies hilft Ihnen, Fehler in der Zukunft zu vermeiden 

function longestWord(string) {
    var str = string.split(" ");
    var longest = 0;
    var Word = null;
    str.forEach(function(str) {
        if (longest < str.length) {
            longest = str.length;
            Word = str;
        }
    });
    return Word;
}
console.log(longestWord("pride and prejudice"));

Ihr ursprüngliches Problem war nur der str.length - 1 hätte gerade str.length sein sollen, ursprünglich wären Sie nicht zum letzten Element des Arrays gekommen

4
aaronman

Der Index geht auf str.length -1:

for (var i = 0; i < str.length - 1; i++) {

Das letzte Wort wird also nicht verarbeitet.

Versuchen Sie es mit: longestWord("Pride AAAAAAAAAAAAAAAAAAAAAAAAA and Prejudice"). Sie werden sehen, dass es funktioniert (gibt AAAAAAAAAAAAAAAAAAAAAAAAA zurück).

Im Zweifelsfall lösen Sie den -1 am einfachsten aus der for-Schleife.

for (var i = 0; i < str.length; i++) {

Überprüfen Sie eine Demo mit beiden Versionen (die Problematik und die Problembehebung): Link hier .

3
acdcjunior
for (var i = 0; i < str.length - 1; i++)

zu

for (var i = 0; i <= str.length - 1; i++)

ODER

for (var i = 0; i < str.length; i++)
1
Raj Nathani

Ich finde, dass die .map-Methode hier sehr hilft (dies ist, wenn Sie die Anzahl der Zeichen des Wortes und nicht das Wort selbst möchten):

 function findLongestWord(str) {   
   var array = str.split(/\s+/);
   var wordLength = array.map(function(i) {
     return i.length;                       
   });   
   var largest = Math.max.apply(Math, wordLength);   
   return largest; 
}
1

löst das das problem ??

function longestWord(string) {
    var str = string.split(" ");
    var longest = 0;
    var Word = null;
    for (var i = 0; i <= str.length - 1; i++) {
        if (longest < str[i].length) {
            longest = str[i].length;
            Word = str[i];
        }
    }
    return Word;
}

document.write(longestWord("pride and prejudice"));
1
user6358623
function longestWord(sent){
 var arr = sent.match(/[a-z]+/gi);
 arr.sort(function(a, b){
 return b.length - a.length;
});
 return arr[0];
}
longestWord('hello [email protected]#$%');
// ==> output: hello
1
bekzat

Sie können Ihren Code mit einer Bibliothek wie Lo-Dash vereinfachen:

function longestWord(string) {
    var words = string.split(' ');
    return _.max(words, function(Word) { return Word.length; });
}
1
Gergo Erdosi

ForEach ist in FF schneller, aber langsamer in Chrome...., Aber für die Schleife mit der zwischengespeicherten Länge und Funktion ist das Anwenden/Aufrufen in FF und Chrom recht viel schneller. 

Hoffe, der untenstehende Code hilft:

function getLongest (arrStr) {
  var longest = 0, Word;

  for(var i=0 , len = arrStr.length ; i < len ; i++){

    if(longest < arrStr[i].length) {
      longest =arrStr[i].length;
      Word = arrStr[i];
    }

  }

  return Word;
}

function isLongest (str) {
  var arrayStr = str.split(' ');
  return function(fn) {
    return fn.apply(this,[arrayStr]);
  }
}

isLongest("hello aaaaaaaaaaaaaaaaaaaaaaaaa bbb")(getLongest); //aaaaaaaaaaaaaaaaaaaaaaaaa
1

Ich finde das einfacher

function findLongestWord(str) {
    var longestStr = 0;
    for (var x=0;x<str.split(' ').length;x++){
        if (longestStr < str.split(' ')[x].length){
            longestStr = str.split(' ')[x].length;
        }
    }
    return longestStr;
}
0
Antares

Vielen Dank an alle, das ist der feste Code:

function longestWord(string) {
    var str = string.split(" ");
    var longest = 0;
    var Word = null;
    for (var i = 0; i < str.length; i++) {
        var checkedLetters = "";
        for (var j = 0; j < str[i].length; j++) {
            if (/[a-zA-Z]/.test(str[i][j])) {
                checkedLetters += str[i][j];
            }
        if (longest < checkedLetters.length) {
            longest = checkedLetters.length;
            Word = checkedLetters;
            }
        }
    }
    return Word;
}
0
bard

Eine andere Methode ist die Verwendung von sort:

    function longestWord(string) {
        let longest = 0;
        let str = str.split(" ").sort((Word1,Word2)=>{
        });
        return str[0].length;
   }
   longestWord('I love Python ')
0
Aysun

Gibt es einen bestimmten Grund? 

for (var i = 0; i < str.length - 1; i++)

ist nicht

for (var i = 0; i < str.length - 1; i++)

Das scheint die Ursache zu sein.

0
Zong

Sie müssen verwenden:

for (var i=0;i<=str.length - 1; i++)

Auf diese Weise wird der gesamte Satz gescannt

0

Der folgende Code findet das größte Word und seine Länge aus einer Zeichenfolge. __ Code ist in reinem JavaScript und HTML.

function findLongestWord() {
  var str = document.getElementById('inputText').value;
  calculateLength(str);
}

function calculateLength(str) {
  var substring = str.split(" ");
  var minChar = '';
  for (var i = 0; i <= substring.length - 1; i++) {
    if (substring[i].length >= minChar.length) {
      minChar = substring[i];
    }
  }
  document.getElementById('longChar').innerHTML = 'Longest Word: ' + minChar;
  document.getElementById('longCharLength').innerHTML = 'Longest Word length: ' + minChar.length;
}
<!doctype html>
<html lang="en">

<head>
</head>

<body>
  <input type="text" id="inputText"> <br/>
  <button onclick=findLongestWord()>Click to find longest              Word</button> <br/>
  <div id="longChar"></div> <br/>
  <div id="longCharLength"></div>
</body>
<script src="longestWord.js"></script>

</html>

0
Alok Ranjan

Ich würde sagen, dass die forEach-Schleife die verständlichste Version ist

function longestWord(sen) {
  big_Word = ""
  words = sen.split(" ")
  words.forEach(function(Word){
    if (Word.length > big_Word.length){
        big_Word = Word
    };
  });
return big_Word
};
0
user3815014

Hier ist ein anderer Weg, um es zu lösen.

function findLongestWord(str) {
  var result = [];
  
  var one = str.split(" ");
    
   for (var i = 0; i < one.length; i++) {
    result[i] = one[i].length;
     result.reverse().sort(function(a,b) {
       return b-a;
     });   
   }
  return result[0];
}

0
PKA

Ich werde Sie auf diesen großartigen Artikel verweisen, der drei Wege definiert:

1 - Finden Sie das längste Wort mit einer FOR-Schleife

    function findLongestWord(str) {
  var strSplit = str.split(' ');
  var longestWord = 0;
  for(var i = 0; i < strSplit.length; i++){
    if(strSplit[i].length > longestWord){
    longestWord = strSplit[i].length;
     }
  }
  return longestWord;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

2 - Finden Sie das längste Wort mit der sort () - Methode

function findLongestWord(str) {
  var longestWord = str.split(' ').sort(function(a, b) { return b.length - a.length; });
  return longestWord[0].length;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

3 - Finden Sie das längste Wort mit der Methode remove ()

function findLongestWord(str) {
  var longestWord = str.split(' ').reduce(function(longest, currentWord) {
    return currentWord.length > longest.length ? currentWord : longest;
  }, "");
  return longestWord.length;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

Natürlich gibt es die Länge des größten Words zurück, wenn Sie die Zeichenfolge erhalten möchten. Beseitigen Sie einfach die Länge im Rückgabe-Teil.

0
Babak Habibi

Dies scheint der einfachste Weg zu sein.

function longestWord(string) {
    var str = string.split(" ");
    var longest = 0;
    var Word = null;

    str.forEach(function(str) {
        if (longest < str.length) {
            longest = str.length;
            Word = str;
        }
    });

return Word;

}

0
Matt.Talbot

VERSUCHE DIES

 function longest(string) {
        var str = string.split(" ");
        var longest = 0;
        var Word = null;
        for (var i = 0; i <= str.length - 1; i++) {
            if (longest < str[i].length) {
                longest = str[i].length;
                Word = str[i];
            }
        }
        return Word;
    }
0
John Kahenya
    function findLongestWord(str) {
       let stringArray = str.split(" ");
       stringArray.sort(function(a, b){
          return a.split('').length < b.split('').length;
       })
       return stringArray[0];
    }

    findLongestWord("The quick brown fox jumped over the lazy dog");
0
ganesh kalje

lösungen sind unvollständig. was ist, wenn es r 2 oder mehr Wörter gibt, die die gleiche Länge haben. Hier ist eine bessere Lösung:

longest = str => {
  let words = str.split(" ");
  let size = 0;
  let max = [""];

  for (let i = 0; i < words.length; i++) {
    if (words[i].length > size) {
      size = words[i].length;
    }
    if (max[max.length - 1].length < words[i].length) {
      max = [];
      max.Push(words[i]);
    } else {
      max = [...max, words[i]];
    }
  }
  return max;
};
0
Yilmaz

Mit der sort () -Methode werden die Elemente eines Arrays nach einem Sortierkriterium sortiert und anschließend die Länge des ersten Elements dieses Arrays und somit das längste Word zurückgegeben.

function longest(string){
    var longestWord = string.split(' ').sort(function(a,b){
        return b.length - a.length;
    });
    return longestWord[0];
}
0
fidel m.