FreeCodeCamp Javascript基础算法总结

算法是描述如何处理某个问题的一系列步骤。
要写一个有效的算法，你需要先将一个特定的问题分解为小的部分，并仔细思考如何用代码解决每个部分。

将摄氏度转换为华氏度

将摄氏度转换为华氏度的计算方式为：摄氏度乘以 9/5 然后加上 32。
输入参数 celsius 代表一个摄氏度的温度。 使用已定义的变量 fahrenheit，并赋值为相应的华氏度的温度值。 根据上述转换公式来进行转换。

function convertToF(celsius) {
  let fahrenheit = celsius*9/5+32;
  return fahrenheit;
}

convertToF(30);
复制代码

反转字符串

请反转传入函数的字符串。
在反转字符串之前，你可能需要将其切分成包含字符的数组。
函数的返回结果应为字符串。

function reverseString(str) {
  return str.split("").reverse().join("");
}

reverseString("hello");
复制代码

计算整数的阶乘

返回一个给定整数的阶乘计算结果。
对于整数 n，n 的阶乘就是所有小于等于 n 的正整数的乘积。
阶乘通常用符号 n! 来表示。
例如：5! = 1 * 2 * 3 * 4 * 5 = 120

function factorialize(num) {
return Array(num).fill(0).reduce((acc,curr,idx)=>{
  return acc*(idx+1)
},1)
}

factorialize(5);
复制代码

找出字符串中的最长单词

返回给出的句子中，最长单词的长度。
函数的返回值应是一个数字。

function findLongestWordLength(str) {
  return str.split(" ").reduce((acc,curr)=>{
    return Math.max(acc,curr.length)
  },0);
}

findLongestWordLength("The quick brown fox jumped over the lazy dog");
复制代码

找出多个数组中的最大数字

请返回一个数组，该数组由参数中每个子数组中的最大数字组成。 为简单起见，给出的数组总会包含 4 个子数组。
别忘了，你可以通过 for 循环遍历一个数组，并用 arr[i]的写法来访问数组中的元素。

function largestOfFour(arr) {
  return arr.reduce((acc,curr)=>{
    acc.push(Math.max(...curr))
    return acc;
  },[])
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
复制代码

确定结尾

检查字符串（第一个参数 str）是否以给定的目标字符串（第二个参数 target）结束。
这个挑战 可以 用 ES2015 引入的 .endsWith() 方法来解决。但在这个挑战中，请使用 JavaScript 的字符串子串方法。

function confirmEnding(str, target) {
  //return str.endsWith(target)
  return str.substring(str.length-target.length)==target;;
}

confirmEnding("Bastian", "n");
复制代码

重复字符串

将一个给定的字符串 str（第一个参数）重复输出 num（第二个参数）次。 如果 num 不是正数，返回空字符串。

function repeatStringNumTimes(str, num) {
  if (num > 0) {
    return Array(num).fill(str).reduce((acc, curr) => {
      return acc + curr
    }, "")
  } else {
    return ""
  }
}

repeatStringNumTimes("abc", 3);
复制代码

截断字符串

如果传入的字符串（第一个参数）的长度大于传入的值（第二个参数），请在这个位置截断它， 并在后面加上 …，然后返回结果。

function truncateString(str, num) {
  return str.length > num ? str.slice(0, num) + "..." : str;
}

truncateString("A-tisket a-tasket A green and yellow basket", 8);
复制代码

按参数过滤数组

请写一个函数来检查数组（第一个参数 arr）中的元素，并返回数组中第一个通过校验测试的元素。 其中，“通过校验测试”指的是对于数组中的一个元素 x，若 func(x) 返回的结果为 true，则校验测试通过。 如果没有元素通过测试，请返回 undefined

function findElement(arr, func) {
  let num = arr.findIndex(item => func(item));
  return arr[num];
}

findElement([1, 2, 3, 4], num => num % 2 === 0);
复制代码

基本类型Boolean值检查

检查一个值是否是基本类型中的布尔值（boolean）类型。 函数应返回 true 或者 false。
基本类型中的布尔值为 true 或者 false。

function booWho(bool) {
  return typeof bool === "boolean";
}

booWho(null);
复制代码

居中单词首字母大写

请将传入的字符串中，每个单词的第一个字母变成大写并返回。 注意除首字母外，其余的字符都应是小写的。

function titleCase(str) {
  return str.toLowerCase().split(" ").map((item => {
    let first = item.charAt(0);
    return first.toUpperCase() + item.substr(1)
  })).join(" ")
}

titleCase("I'm a little tea pot");
复制代码

Slice 与 Splice

本挑战的输入参数为两个数组和一个索引值。
将第一个数组中的所有元素依次复制到第二个数组中。
请注意，你需要从第二个数组索引值为 n 的地方开始插入。
最后，请返回插入元素后的数组。 作为输入参数的两个数组在函数执行前后应保持不变。

function frankenSplice(arr1, arr2, n) {
  let newArr = arr2.slice()
  newArr.splice(n, 0, ...arr1)
  return newArr;
}

frankenSplice([1, 2, 3], [4, 5, 6], 1);
复制代码

过滤数组中的假值

从数组中移除所有假值（falsy values）。
JavaScript 中的假值有 false、null、0、””、undefined、NaN。
提示：可以考虑将每个值都转换为布尔值（boolean）。

function bouncer(arr) {
  return arr.filter(item => Boolean(item));
}

bouncer([7, "ate", "", false, 9]);
复制代码

找出元素在排序后数组中的索引

数组（第一个参数）在排序后，将一个值（第二个参数）插入该数组，并使数组保持有序。返回这个新插入元素的最小索引值。 返回值应为一个数字。
例如，getIndexToIns([1,2,3,4], 1.5) 应该返回 1 因为1.5 大于 1（索引为 0）且小于 2（索引为 1）。
同样地，getIndexToIns([20,3,5], 19) 应该返回 2。 因为数组排序后会变成 [3,5,20]，而 19 小于 20（索引为 2）且大于 5（索引为 1）。

function getIndexToIns(arr, num) {
  return [...arr, num].sort((a, b) => a - b).findIndex(item => item === num);
}

getIndexToIns([40, 60], 50);
复制代码

比较字符

如果数组里的第一个字符串包含了第二个字符串中的所有字母，则返回 true。
例如，[“hello”, “Hello”] 应该返回 true。因为在忽略大小写的情况下，第一个字符串包含了第二个字符串里出现的所有字母。
[“hello”, “hey”] 应该返回 false。因为 hello 并不包含字符 y。
最后，[“Alien”, “line”] 应该返回 true。因为 line 中的所有字母都出现在了 Alien 中。

function mutation(arr) {
  let list = arr.map(item => item.toLowerCase())
  return list[1].split("").every(item => list[0].includes(item))
}

mutation(["hello", "hey"]);
复制代码

分割数组

请编写一个函数，该函数将一个数组（第一个参数）拆分成若干长度为 size（第二个参数）的子数组，并将它们作为二维数组返回。

function chunkArrayInGroups(arr, size) {
  let list = []
  for (let i = 0; i < arr.length; i += size) {
    list.push(arr.slice(i, size + i))
  }
  return list
}

chunkArrayInGroups(["a", "b", "c", "d"], 2);
复制代码