Поиск самой длинной строки в массиве

Я бы сделал что-то вроде этого

var arr = ['first item', 'second item is longer than the third one', 
           'third longish item'];

var lgth = 0;
var longest;

for(var i=0; i < arr.length; i++){
    if(arr[i].length > lgth){
        var lgth = arr[i].length;
        longest = arr[i];
    }      
} 

alert(longest);

http://jsfiddle.net/jasongennaro/MLqLq/

новый ответ на старый вопрос: в ES6 вы можете сделать короче:

Math.max(...(x.map(el => el.length)));

var arr = [ 'fdgdfgdfg', 'gdfgf', 'gdfgdfhawsdgd', 'gdf', 'gdfhdfhjurvweadsd' ];
arr.sort(function (a, b) { return b.length - a.length })[0];

Используя Массив.prototype - (сортировка похожа на то, что было опубликовано @katsPaugh и @deceze, пока я делал скрипку)

ДЕМО ЗДЕСЬ

var arr = [
    "2 --",
    "3 ---",
    "4 ----",
    "1 -",
    "5 -----"
];

Array.prototype.longest=function() {
    return this.sort(
      function(a,b) {  
        if (a.length > b.length) return -1;
        if (a.length < b.length) return 1;
          return 0
      }
    )[0];
}
alert(arr.longest());    

Я вижу самое короткое решение

function findLong(s){
  return Math.max.apply(null, s.split(' ').map(w => w.length));
}

Я сделаю что-то вроде этого:

function findLongestWord(str) {
var array = str.split(" ");
var maxLength=array[0].length;
for(var i=0; i < array.length; i++ ) {
if(array[i].length > maxLength) maxLength = array[i].length}
return maxLength;}

findLongestWord("What if we try a super-long word such as otorhinolaryngology");

Если ваша строка уже разделена на массив, вам не понадобится разделенная часть.

function findLongestWord(str) {
  str = str.split(' ');
  var longest = 0;

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

может быть, не самый быстрый, но, безусловно, довольно четкий:

function findLongestWord(array) {
  var longestWord = "";

  array.forEach(function(word) {
    if(word.length > longestWord.length) {
      longestWord = word;
    }
  });

  return longestWord;
}

var word = findLongestWord(["The","quick","brown", "fox", "jumped", "over", "the", "lazy", "dog"]);
console.log(word); // result is "jumped"

функции массива foreach, которая поддерживается начиная с ИЕ9+.

Я был вдохновлен функцией Джейсона и сделал несколько улучшений в ней и получил в результате довольно быстрый finder:

function timo_longest(a) {
  var c = 0, d = 0, l = 0, i = a.length;
  if (i) while (i--) {
    d = a[i].length;
    if (d > c) {
      l = i; c = d;
    }
  }
  return a[l];
}
arr=["First", "Second", "Third"];
var longest = timo_longest(arr);

скорость результаты: http://jsperf.com/longest-string-in-array/7

var longest = (arr) => {
  let sum = 0
  arr.map((e) => {
    sum = e.length > sum ? e.length : sum
  })
  return sum
}

это может быть работа

function findLongestWord(str) {
  str = str.split(" ");
  var sorted = str.sort(function(prev,current){
    return prev.length - current.length;   
  });
  var index = sorted.length;
  str = sorted[index-1];
  return str;
}
findLongestWord("The quick brown fox jumped over the lazy dog");

в случае, если вы ожидаете более одного максимума это будет работать:

_.maxBy(Object.entries(_.groupBy(x, y => y.length)), y => parseInt(y[0]))[1]

он использует lodash и возвращает массив.

С ES6 поддерживается также дублировать строку

var allLongestStrings = arrayOfStrings => {
  let maxLng = Math.max(...arrayOfStrings.map( elem => elem.length))
  return arrayOfStrings.filter(elem => elem.length === maxLng)
}

let arrayOfStrings = ["aba", "aa", "ad", "vcd","aba"]

console.log(allLongestStrings(arrayOfStrings))

var array = ["hello","falsey","undefined"];
var findLongestWord = function(array){
    var longest = array.reduce(function(a,b){
    return (a.length > b.length) ? a : b;
  });
    return longest;
}
findLongestWord(array);

Это действительно просто глючный код, который я написал 5 минут назад. У меня нет времени, чтобы исправить ошибки, но если вы получите идею, вы можете изменить и использовать его.

Array.prototype.MaxBy = function(fn) {        
    var max = 0;
    var element;
    for (var i = 0; i < this.length; i++) {
        var ret = fn(this[i]);
        if (ret > max) {
            max = ret;
            element = this[i];
        }
    }
    return element;
};

function showOldestPerson() {
    var array = [{ Name: "cihat", Age: 28 }, { Name: "Ali", Age: 30 }, { Name: "Kutlu", Age: 27}];

    var person = array.MaxBy(function(item) {
        return item.Age;
    });

    alert(person.Name);
}