基础算法脚本

将字符串翻转：

function reverseString(str) {
  //法一：
  /*
  let arr=[];
  for(let i=0;i<str.length;i++){
    arr.unshift(str[i]);
  }
  //console.log(arr);//[ 'o', 'l', 'l', 'e', 'h' ]
  str='';
  for(let i=0;i<arr.length;i++){
    str=str+arr[i];
  }
  //console.log(str);//olleh
  return str;
  */
  //法二：
  let reversedStr = "";
  for (let i = str.length - 1; i >= 0; i--) {
    reversedStr += str[i];
  }
  //法三：
  /* 
  return str
    .split("")
    .reverse()
    .join("");
  */
  return reversedStr;
}
//调用：
console.log(reverseString("hello")); //olleh

求整数的阶乘：

只有大于或等于零的整数才能计算阶乘，阶乘是所有小于或等于n的正整数的乘积，简写为n!，例如：5！=1 * 2 * 3 * 4 * 5 = 120

function factorialize(num) {
  //法一：
  /*let product = 1;
  for (let i = 2; i <= num; i++) {
    product *= i;
  }
  return product;*/
  //法二：
  /*if (num === 0) {
    return 1;
  }
  return num * factorialize(num - 1); */
  //法三：
  return num < 0 ? 1 :
    new Array(num)
      .fill(undefined)
      .reduce((product, _, index) => product * (index + 1), 1); 
}

//法四：
/*function factorialize(num, factorial = 1) {
  if (num === 0) {
    return factorial;
  } else {
    return factorialize(num - 1, factorial * num);
  }
}*/

console.log(factorialize(5)); //120

查找字符串中最长的单词，返回其长度：

function findLongestWordLength(str) {
  //法一：
  //return Math.max(...str.split(" ").map(word => word.length));
  //法二：
  //return str.split(' ').reduce(function(longest, word) {return Math.max(longest, word.length)}, 0);
  //法三：
  /*let words = str.split(' ');
  let maxLength = 0;

  for (let i = 0; i < words.length; i++) {
    if (words[i].length > maxLength) {
      maxLength = words[i].length;
    }
  }
  return maxLength;*/
  //法四：
  /*const words = str.split(" ");
  if (words.length == 1) {
    return words[0].length;
  }
  return Math.max(words[0].length,findLongestWordLength(words.slice(1).join(" ")));*/
  //法五：
let longestLength = 0;
let currentLength = 0;
for (let i = 0; i < str.length; i++) {
  if (str[i] === " ") {
    if (currentLength > longestLength) longestLength = currentLength;
    currentLength = 0;
  } else {
    currentLength++;
  }
}
if (currentLength > longestLength) {
  longestLength = currentLength;
}
return longestLength;

}
//调用：
console.log(findLongestWordLength("The quick brown fox jumped over the lazy dog")); //6

查找数组中最大的数字：

编写函数，返回二维数组里每个子数组中的最大数字组成的数组。代码如下：

//法一：
/*function largestOfFour(arr) {
  let sumarr=[];
  for(let i=0;i<arr.length;i++){
    //每次一维循环一开始，就将二维的首个元素赋给cabin，方便后面判断大小。
    let cabin=arr[i][0];
    //由于二维的首个元素已取到了，故里层循环从第二个元素（索引1）开始初始化。
    for(let j=1;j<arr[i].length;j++){
      if (arr[i][j]>cabin){
        cabin=arr[i][j];
      }
    }
    sumarr[i]=cabin;
  }
  return sumarr;
}
*/
//法二：
/*function largestOfFour(arr) {
  return arr.map(function(group) {
    return group.reduce(function(prev, current) {
      return current > prev ? current : prev;
    });
  });
}*/

//法三:
/*function largestOfFour(arr) {
  return arr.map(Function.apply.bind(Math.max, null));
}*/
//法四：
function largestOfFour(arr, finalArr = []) {
  return !arr.length
    ? finalArr
    : largestOfFour(arr.slice(1), finalArr.concat(Math.max(...arr[0])))
}

//调用：
console.log(largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])); //[ 5, 27, 39, 1001 ]

不使用.endsWith()方法，而是使用JS的子串方法检查字符串（str）是否以给定的目标字符串（target）结尾：

//法一
/*function confirmEnding(str, target) {
  //let regex='/'+target+'$'+'/'+'i';
  let regex=new RegExp(target+'$','i');
  return regex.test(str);  
}*/
//法二：
/*function confirmEnding(str, target) {
  return str.slice(str.length-target.length)===target;
}*/  
//法三：
function confirmEnding(str, target) {
  return str.slice(-target.length) === target
}

//调用：
console.log(confirmEnding("Bastian", "n"));//true

不使用内置的.repeat()方法，而是使用其他方法把字符串（str）重复num次，如果num不是正数，则返回空字符串：

//法一：
/*function repeatStringNumTimes(str, num) {
  let sumstr='';
  //用(let i = 0; i < num; i++)也是一样的
  for(let i=num;i>=1;i--){
    sumstr+=str; 
  }
  return sumstr;
}*/
//法二：
/*function repeatStringNumTimes(str, num) {
  if (num < 1) {
    return "";
  } else {
    return str + repeatStringNumTimes(str, num - 1);
  }
}*/
//法三：
function repeatStringNumTimes(str, num) {
  return num > 0 ? str + repeatStringNumTimes(str, num - 1) : '';
}
//调用：
console.log(repeatStringNumTimes("abc", 3));

如果str长度超过num，则截断str返回以…结尾的截断字符串。num大于或等于str的长度时就不用加...，直接返回str。

//法一：
/*function truncateString(str, num) {
  if(num<str.length){
    return str.slice(0,num)+'...';
  }
  else{
    return str;
  }
}*/
//法二：
function truncateString(str, num) {
  return str.length > num ? str.slice(0, num) + "..." : str;
}
console.log(truncateString("A-tisket a-tasket A green and yellow basket", 8));

创建一个函数，查看数组arr并返回其中通过“真值测试”的第一个元素。即给定一个元素x，如果func(x)为true，则通过“真值测试”。如果没有元素通过测试，则返回undefined：

//法一：
/*function findElement(arr, func) {
  for(let i=0;i<arr.length;i++){
    if(func(arr[i])){
      return arr[i];
    }
  }
  return undefined;//这句要放在for循环外面，确保循环里的return不执行，才执行这里的return！
}*/
//法二：
/*function findElement(arr, func) {
  return arr.find(func);
}*/
//法三：
/*function findElement(arr, func) {
  return arr[arr.map(func).indexOf(true)];
}*/
//法四：
function findElement(arr, func) {
  if (arr.length > 0 && !func(arr[0])) {
    return findElement(arr.slice(1), func);
  } else {
    return arr[0];
  }
}

console.log(findElement([1, 2, 3, 4], num => num % 2 === 0));

检查值是否被分类为布尔基元（真或假），返回true或false。

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

console.log(booWho(false));//true

返回str，确保每个单词的第一个字母大写，单词的其余部分为小写，连接词如and、of开头字母也要大写：

//法一：
/*function titleCase(str) {
  const newTitle = str.split(" ");
  const updatedTitle = [];
  for (let st in newTitle) {
    updatedTitle[st] = newTitle[st][0].toUpperCase() + newTitle[st].slice(1).toLowerCase();
  }
  return updatedTitle.join(" ");
}*/
//法二：
/*function titleCase(str) {
  return str
    .toLowerCase()
    .split(" ")
    .map(val => val.replace(val.charAt(0), val.charAt(0).toUpperCase()))
    .join(" ");
}*/
//法三：
function titleCase(str) {
  return str
    .toLowerCase()
    .replace(/(^|\s)\S/g, L => L.toUpperCase());//字符串开头（^）或在任何空白字符（\s）之后，查找整个（g）字符串的所有非空白字符（\S）
}

console.log(titleCase("I'm a little tea pot on the desk"));//I'm A Little Tea Pot On The Desk

创建函数，按顺序将arr1的每个元素复制到arr2中，在arr2的索引n处插入元素，返回结果数组。函数运行后，输入数组应保持不变：

//法一：
/*function frankenSplice(arr1, arr2, n) {
  //在不改变arr1或arr2的情况下返回新数组，因此我们创建cut，并使用slice从arr2添加所有项
  let cut=arr2.slice();//[ 4, 5, 6 ]
  //splice会改变数组并可用于添加新元素，因此我们用它将arr1的内容添加到cut中。
  //从索引n处插入数据，0是因为不想删除任何元素，扩展符...引入arr1的全部内容。
  cut.splice(n,0,...arr1);
  return cut;
}*/
//法二：
/*function frankenSplice(arr1, arr2, n) {
  let localArray = arr2.slice();
  for (let i = 0; i < arr1.length; i++) {
    localArray.splice(n, 0, arr1[i]);
    n++;
  }
  return localArray;
}*/
//法三：
function frankenSplice(arr1, arr2, n) {
  /*第一个扩展符...与slice返回从索引0到“n”的arr2部分
   第二个扩展符...返回来自arr1的所有元素
   第三个扩展符...与slice将从索引“n”开始的所有元素返回到数组的末尾。*/
  return [...arr2.slice(0, n), ...arr1, ...arr2.slice(n)];
}
//调用
console.log(frankenSplice([1, 2, 3], [4, 5, 6], 1)); //[ 4, 1, 2, 3, 5, 6 ]

JavaScript中的Falsy值包括false, null, 0, "", undefined 和 NaN。

创建函数，从数组中删除所有Falsy值：

//法一：
/*function bouncer(arr) {
  let conarr=[];
  for(let i=0;i<arr.length;i++){
    if(arr[i]){
      conarr.push(arr[i]);
    }
  }
  return conarr;
}*/
//法二：
function bouncer(arr) {
  return arr.filter(Boolean);
}

console.log(bouncer([7, "ate", "", false, 9])); //[ 7, 'ate', 9 ]

创建函数，返回（第二个参数）排序后应插入数组（第一个参数）的最低索引，返回值应为数字：

例如：getIndexToIns（[20,3,5]，19）应该返回2，因为数组排序后看起来像[3,5,20]，19小于20（索引2），大于5（索引1）。

//法一：
/*function getIndexToIns(arr, num) {
  arr.push(num);
  //console.log(arr);//[ 5, 3, 20, 3, 5 ]
  arr.sort((a, b) => a - b);
  //console.log(arr);//[ 3, 3, 5, 5, 20 ]
  return arr.indexOf(num);
}*/
//法二：上述语句可以简写为：
/*function getIndexToIns(arr, num) {
  return arr.concat(num).sort((a, b) => a - b).indexOf(num);
}*/
//法三：
/*function getIndexToIns(arr, num) {
  arr.sort((a, b) => a - b);
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] >= num)
      return i;
  }
  return arr.length;
}*/
//法四：
/*function getIndexToIns(arr, num) {
  return arr.filter(val => num > val).length;
}*/
//法五：
function getIndexToIns(arr, num) {
  let index = arr
    .sort((curr, next) => curr - next)
    .findIndex(currNum => num <= currNum);
  return index === -1 ? arr.length : index;
}
//调用：
console.log(getIndexToIns([5, 3, 20, 3], 5)); //2

检查数组第一个元素中的字符串是否包含数组第二个元素中字符串的所有字母，是则返回true，否则返回false。

//法一：
function mutation(arr) {
  let low1=arr[0].toLowerCase();
  let low2=arr[1].toLowerCase();
  //console.log(low1);//mary
  //console.log(low2);//aarmy
  for(let i=0;i<low2.length;i++){
    if(low1.indexOf(low2[i])<0){
      return false;
    }
  }
  return true;
}
//法二：
/*function mutation(arr) {
  return arr[1]
    .toLowerCase()
    .split("")
    .every(function(letter) {
      return arr[0].toLowerCase().indexOf(letter) !== -1;
    });
}*/
//法三：
//在专业代码中通常不建议这样深度嵌套（这里嵌套了三重）
/*function mutation([ target, test ], i = 0) {
  target = target.toLowerCase();
  test = test.toLowerCase();
  return i >= test.length
    ? true
    : !target.includes(test[i])
      ? false
      : mutation([ target, test ], i + 1);
}*/
//调用：
console.log(mutation(["Mary", "Aarmy"])); //true

编写函数，将数组arr拆分为size大小的组，并将其作为二维数组返回：

//法一：
function chunkArrayInGroups(arr, size) {
  let newarr=[];
  for(let i=0;i<arr.length;i+=size){
    newarr.push(arr.slice(i,i+size));
  }
  return newarr;
}
//法二：
/* 
function chunkArrayInGroups(arr, size) {
  let temp = [];
  let result = [];

  for (let a = 0; a < arr.length; a++) {
    if (a % size !== size - 1) temp.push(arr[a]);
    else {
      temp.push(arr[a]);
      result.push(temp);
      temp = [];
    }
  }

  if (temp.length !== 0) result.push(temp);
  return result;
}*/
//法三：
/*function chunkArrayInGroups(arr, size) {
  // Break it up.
  let newArr = [];
  let i = 0;

  while (i < arr.length) {
    newArr.push(arr.slice(i, i + size));
    i += size;
  }
  return newArr;
}*/
//法四：
/*
function chunkArrayInGroups(arr, size) {
  let newArr = [];
  while (arr.length > 0) {
    newArr.push(arr.splice(0, size));
  }
  return newArr;
}*/
//法五：
/*function chunkArrayInGroups(arr, size) {
  if (arr.length <= size) {
    return [arr];
  } else {
    return [arr.slice(0, size)].concat(
      chunkArrayInGroups(arr.slice(size), size)
    );
  }
}*/

console.log(chunkArrayInGroups(["a", "b", "c", "d"], 2));//[ [ 'a', 'b' ], [ 'c', 'd' ] ]

。。。