Tìm chuỗi dài nhất trong mảng

Có cách nào ngắn gọn để tìm chuỗi dài nhất trong một mảng chuỗi không?

Một cái gì đó như thế arr.Max(x => x.Length);nào?

Có sẵn kể từ Javascript 1.8 / ECMAScript 5 và có sẵn trong hầu hết các trình duyệt cũ hơn :

var longest = arr.reduce(
    function (a, b) {
        return a.length > b.length ? a : b;
    }
);

Nếu không, một giải pháp thay thế an toàn:

var longest = arr.sort(
    function (a, b) {
        return b.length - a.length;
    }
)[0];

Một câu trả lời mới cho một câu hỏi cũ: trong ES6, bạn có thể làm ngắn hơn:

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

Tôi sẽ làm một cái gì đó như thế này

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];
  }
}

console.log(longest);

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

Sử dụng Array.prototype - (sắp xếp tương tự như những gì đã được đăng bởi @katsPaugh và @deceze khi tôi đang thực hiện trò chơi điện tử)

DEMO TẠI ĐÂY

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());    

Tôi cung cấp cách tiếp cận hàm + đệ quy. Xem nhận xét để hiểu cách hoạt động:

const input1 = ['a', 'aa', 'aaa']
const input2 = ['asdf', 'qwer', 'zxcv']
const input3 = ['asdfasdf fdasdf a sd f', ' asdfsdf', 'asdfasdfds', 'asdfsdf', 'asdfsdaf']
const input4 = ['ddd', 'dddddddd', 'dddd', 'ddddd', 'ddd', 'dd', 'd', 'd', 'dddddddddddd']

// Outputs which words has the greater length
// greatestWord :: String -> String -> String
const greatestWord = x => y => 
      x.length > y.length ? x : y
      
// Recursively outputs the first longest word in a series
// longestRec :: String -> [String] -> String
const longestRec = longestWord => ([ nextWord, ...words ]) =>
      //                                ^^^^^^^^^^^^
      // Destructuring lets us get the next word, and remaining ones!
      nextWord // <-- If next word is undefined, then it won't recurse.
        ? longestRec (greatestWord (nextWord) (longestWord)) (words) 
        : longestWord


// Outputs the first longest word in a series
// longest :: [String] -> String
const longest = longestRec ('')

const output1 = longest (input1)
const output2 = longest (input2) 
const output3 = longest (input3)
const output4 = longest (input4)

console.log ('output1: ', output1)
console.log ('output2: ', output2)
console.log ('output3: ', output3)
console.log ('output4: ', output4)

Tôi thấy giải pháp ngắn nhất

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

Có thể không phải là nhanh nhất, nhưng chắc chắn là khá dễ đọc:

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"

Hàm mảng forEach đã được hỗ trợ kể từ IE9 + .

Trong ES6 này có thể được thực hiện với một reduce()cuộc gọi trong O(n)phức tạp như trái ngược với các giải pháp sử dụng sort()đó là O(nlogn):

const getLongestText = (arr) => arr.reduce(
  (savedText, text) => (text.length > savedText.length ? text : savedText),
  '',
);

console.log(getLongestText(['word', 'even-longer-word', 'long-word']))

Tôi lấy cảm hứng từ chức năng của Jason và thực hiện một chút cải tiến cho nó và kết quả là công cụ tìm kiếm khá nhanh:

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);

Kết quả tốc độ: http://jsperf.com/longest-string-in-array/7

Tôi sẽ làm một cái gì đó như thế này:

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");

Nếu chuỗi của bạn đã được chia thành một mảng, bạn sẽ không cần phần tách.

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");

Trong trường hợp bạn mong đợi nhiều hơn một mức tối đa, điều này sẽ hoạt động:

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

Nó sử dụng lodash và trả về một mảng.

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

nó có thể là công việc

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");

Với ES6 cũng được hỗ trợ chuỗi trùng lặp

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))

Các trình duyệt hiện đại hỗ trợ một for...ofvòng lặp. Cách nhanh nhất và ngắn nhất để giải quyết vấn đề này trong Chrome, Safari, Edge và Firefox cũng là cách rõ ràng nhất:

let largest = '';
for (let item of arr) {
  if (item.length > largest.length) largest = item
}

Trong IE, bạn có thể sử dụngArray.forEach ; điều đó vẫn nhanh hơn và rõ ràng hơn so với việc sắp xếp hoặc giảm bớt mảng.

var largest = '';
arr.forEach(function(item) {
  if (item.length > largest.length) largest = item
});

Đây là giải pháp đơn giản của tôi

var arr = ["you", "are", "the", "love", "of", "my", "life"];
var sorted = arr.sort(function (a, b){
     return b.length - a.length;
});

console.log(sorted[0])

function allLongestStrings(array) {
    const newArr=[];
    let temp =    Math.max(...(array.map(el => el.length)));    
     array.forEach(item => {
        if(temp == item.length){
          newArr.push(item);
        }
    });
    return newArr;
}

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);