배열에서 가장 긴 문자열 찾기

string 형 배열에서 가장 긴 문자열을 찾는 짧은 방법이 있습니까?

같은 뭔가 arr.Max(x => x.Length);?

사용 가능한부터 자바 스크립트 1.8 / 인 ECMAScript 5 대부분에서 사용할 수있는 이전 버전의 브라우저 :

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

그렇지 않으면 안전한 대안 :

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

이전 질문에 대한 새로운 답변 : ES6에서는 더 짧게 할 수 있습니다.

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

나는 이렇게 할 것이다

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

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

기능 + 재귀 접근 방식을 제공합니다. 작동 방식을 이해하려면 주석을 참조하십시오.

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)

나는 가장 짧은 해결책을 본다

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

아마도 가장 빠르지는 않지만 확실히 읽기 쉽습니다.

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 배열 함수 는 IE9 + 이후 지원되었습니다 .

ES6에서는 다음 을 사용 하는 솔루션과 달리 복잡한 reduce()호출 로 수행 할 수 있습니다 .O(n)sort()O(nlogn)

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

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

저는 Jason의 기능에 영감을 받아 약간의 개선을했고 결과적으로 검색 속도가 빨라졌습니다.

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

다음과 같이 할 것입니다.

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

둘 이상의 최대 값을 예상하는 경우 다음과 같이 작동합니다.

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

lodash를 사용하고 배열을 반환합니다.

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

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

최신 브라우저는 for...of루프를 지원합니다 . Chrome, Safari, Edge 및 Firefox에서이 문제를 해결하는 가장 빠르고 짧은 방법도 가장 명확합니다.

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

IE에서는Array.forEach ; 배열을 정렬하거나 줄이는 것보다 더 빠르고 명확합니다.

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

이것은 나의 간단한 해결책입니다

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