const longestReducer = (pre, cur) => pre.length > cur.length ? pre : cur
const longest = array.reduce(longestReducer)

const longestReducer = (pre, cur) => {
    if (!pre.length || pre[0].length < cur.length) return [cur]
    if (pre[0].length === cur.length) {
        pre.push(cur)
        return pre
    } 
    return pre
}
const longest = array.reduce(longestReducer, [])

function maxLengthString(str){
 str.split('').reduce(function(start,end){
   return start>end?start.length:end.length
 })
}

const str = 'aaa b cc, hello word'
str.split(/\s|,/).reduce((acc, cur) => acc > cur.length ? acc : cur.length)

const getLongestWord = (str, sperator = " ") => {
  if (!str) {
    return str;
  }

  let longestWord = {
    len: 0,
    word: ""
  };

  str
    .replace(/[,\.;]/g, "")
    .split(sperator)
    .forEach(word => {
      const { len } = longestWord;
      if (word.length > len) {
        longestWord = {
          len: word.length,
          word
        };
      }
    });
  return longestWord;
};

console.log(getLongestWord("I have an apple."));
console.log(getLongestWord("I have a pen."));

function maxWords(str) {
  const wordsGroup = str.split("")
    .reduce((map, cur) => map.set(cur, map.has(cur) ? map.get(cur) + 1 : 0), new Map());
  return [...wordsGroup.entries()].reduce((pre, cur) => {
    return pre[1] > cur[1] ? pre : cur
  })[0]
}

function findMax(str) {
  return str.split(" ").reduce(
    (cacheWord, it) => {
      if (it.length > cacheWord.length) {
        cacheword = {
          length: it.length,
          word: it
        };
      }

      return cacheword;
    },
    { length: 0, word: "" }
  );
}
console.log(findMax('123 1234 123456 123'))

function findLongestWord(str) {
  var stringArr = str.split(' ')

  return stringArr.reduce(function(prev, next) {
    // 返回值为参数与当前字符串中较大的数
    // 返回值会作为下次计算的 prev 传入
    return Math.max(prev, next.length)
  }, 0)
}

function findLongestWord(str) {
    if (!str) return str
    
    str = str.replace(/[,\.]/g, '')
    const words = str.split(' ')
    const sortedWords = words.sort((a,b) => b.length - a.length)

    return sortedWords[0]
}

console.log(findLongestWord('I have a apple, I have a pen, duang, applepen.'))

function maxStrStr(str) {
  let res = ''
  str.split(' ').forEach(item => {
    console.log(item.length > res.length)
    if (item.length > res.length) {
      res = item
    }
  })
  return res
}

console.log(maxStrStr('a bc def ab'))

const str = "aaa b cc, hello word";

function LongestWord(str) {
  str = str.replace(/[^a-zA-Z0-9\s]/g, "");

  return str.split(" ").sort((a, b) => {
    return b.length - a.length;
  })[0];
}
console.log(LongestWord(str));

function getMaxLen(str) {
  const array = str.match(/\b[a-zA-Z]+\b/g)
  return array.reduce((acc, cur) => {
    if (cur.length > acc.length) return cur
    return acc
  }, '')
}

console.log(getMaxLen('sdfn hdo fjqw hqfweoubhr oiqwehuio rhqweouihr pqwep hpidofj jdfsdjfp ojep jfpej 134 5134 31 e geg dfg df g')) // hqfweoubhr

// 简单易懂，略带点骚

function getMostLength(str) {
   if (!str) return;
   const arr = str.split(' ');
   let itemLengthArr = [];
   arr.forEach(item => {
      itemLengthArr.push(item.length);
   });

   const max = Math.max(...itemLengthArr);
   return { item: arr[itemLengthArr.indexOf(max)], length: max };
}

const maxLen = str => Math.max(...str.split(/\s+/g).map(i => i.length))

/**
 * @description: 查找英文字符串中最长的单词，并返回它的长度
 * @param {str} string 英文字符串 
 * @return {number} 
 */
function findLongestWordLength(str) {
    let longestWord = "";
    let currentWord = "";

    //逐字母遍历
    for (let i = 0; i < str.length; i++) {
        if (str.charAt(i) === " ") { //当前字符是空格
            if (currentWord.length > longestWord.length) longestWord = currentWord; //检查该单词是否是最长的单词
            currentWord = ""; //清除当前单词
        } else {
            currentWord += str.charAt(i); //非空格字符，添加该字符继续创建单词
        }
    }
    if (currentWord > longestWord) longestWord = currentWord; //到达字符串末尾，再次检查当前单词是否是最长的单词
    return longestWord;
}

const longest = findLongestWordLength("The quick brown fox jumped over the lazy dog");
console.log(longest);

let str = 'Thank you for your company over the years, you are my best friend and love you!';

function findLongestWord(str) {
    if (typeof str !== 'string') return false;
    const arr = str.split(' ');
    let max = arr[0];
    for (let i = 1; i < arr.length; i++) {
        max = max.length > arr[i].length ? max : arr[i];
    }
    console.log(max);
}

let str = 'Thank you for your company over the years, you are my best friend and love you!';
function findLongestWord(str) {
    if (typeof str !== 'string') return false;
    const matchArr = str.match(/[a-zA-Z]+/gi);
    return matchArr.reduce((acc, cur) => {
        if (acc.length > cur.length) return acc;
        return cur;
    });
}

function findLongestWordLength(str) {
  // 将字符串分割成单词数组
  var words = str.split(' ');

  // 初始化最长单词长度
  var maxLength = 0;

  // 遍历单词数组，更新最长单词长度
  for (var i = 0; i < words.length; i++) {
    // 移除单词中的标点符号等非字母字符
    var cleanWord = words[i].replace(/[^a-zA-Z]/g, '');

    // 更新最长单词长度
    if (cleanWord.length > maxLength) {
      maxLength = cleanWord.length;
    }
  }

  return maxLength;
}

// 示例用法
var sentence = "The quick brown fox jumps over the lazy dog.";
var result = findLongestWordLength(sentence);
console.log(result);  // 输出：6（因为"jumps"是最长的单词）