递归
JavaScript中允许函数递归调用，示例：
function factorial(n){
if( n === 1){
return 1
}else{
return n*factorial(n-1)
}
}
console.log(factorial(6))
当一个函数呗递归调用时，递归没有完成，函数的计算结果会被暂时挂起，
上例的执行过程如下：
6 * factoial(5)
6 * 5 * factoial(4)
6 * 5 * 4 * factoial(3)
6 * 5 * 4 * 3 * factoial(2)
6 * 5 * 4 * 3 * 2 * factoial(1)
数组
定义：一个存储元素的线性集合，元素可以通过索引来任意存取，索引通常是数字。
数组的第一项下标是0
创建一个数组
let array = []
该数组的长度为0，
array.length // 0
也可以通过调用构造函数来创建数组
let array1 = new Array()
数组的读写
可以使用[]操作符将数据赋值给数组,将1~100的数字赋给一个数组 示例如下：
let num = []
for(let i = 0;i<100;i++){
num[i] = i +1
}
可以读取数组中的元素
let num = [1,2,3,4,5,6,7]
console.log(num[4]) // 5
数组的常用方法：
- indexOf()函数用来查找传进来的参数是否在目标数组中存在，如果存在就返回下标，如果不存在就返回-1
// indexOf()
let names = ["zhangsan","lisi"]
console.log(names.indexOf("zhangsan")) // 0
console.log(names.indexOf("wangwu")) // -1
- join()和toString()方法可以将数组转成字符串
let names = ["zhangsan","lisi"]
let str1 = names.join()
console.log(str1) // zhangsan,lisi
let str2 = names.toString()
console.log(str2) // zhangsan,lisi
// 两个方法不同的是 join()方法可以传递参数,参数的意义是使用该参数链接数组的各个元素
let str3 = names.join("-")
console.log(str3) // zhangsan-lisi
- concat() 该方法可以合并多个数组 创建一个新数组
let arr1 = [1,2,3]
let arr2 = [4,5,6]
let arr3 = [7,8]
let newArr = arr1.concat(arr2,arr3)
console.log(newArr) // [1,2,3,4,5,6,7,8]
- splice()方法可以从现有数组里截取一个新数组，该方法的第一个参数是截取的起始索引，第二个参数是截取的长度, 第三个参数是添加的元素
let arr = [1,2,3,4,5,6,7,8]
let arr1 = arr.splice(2,3)
console.log(arr1) // [3,4,5]
console.log(arr) // [1,2,6,7,8]
- push() 该方法用于向数组尾部中添加元素
let arr = [1,2,3]
arr.push(4)
console.log(arr) // [1,2,3,4]
- unshift()该方法用于向数组开头添加元素
let arr = [1,2,3]
arr.unshift(4)
console.log(arr) // [4,1,2,3]
- pop() 方法用于删除数组尾部的元素
let arr = [1,2,3]
arr.pop()
console.log(arr) // [1,2]
- reverse()该方法可以将数组翻转
let arr = [1,2,3]
arr.reverse()
console.log(arr) // [3,2,1]
- sort() 该方法用于数组的排序
let arr = [1,2,8,4,5,7,89,32,5]
arr.sort((a,b)=> a-b)
console.log(arr) // [1, 2, 4, 5, 5, 7, 8, 32, 89]
- forEach()该方法接受一个函数作为参数，对数组中的每一个元素使用该方法
let arr = [1, 2, 4, 5, 5, 7, 8, 32, 89]
arr.forEach((item)=>{
console.log(item)
})
// 打印数组的每一项
- every()方法接受一个返回值为布尔值的函数，对数组中的每个元素使用该函数，如果对于所有元素该方法都返回true，该方法就返回true，否则返回false
let arr = [1, 2, 4, 5, 5, 7, 8, 32, 89]
let result = arr.every((item)=>{
return item > 0
})
console.log(result) // true
- some() 方法接受一个返回值为布尔值的函数，只要有一个元素使得该函数为true，该方法就返回true
let arr = [1, 2, 4, 5, 5, 7, 8, 32, 89]
let result = arr.some((item)=>{
return item > 5
})
console.log(result) // true
- reduce() 方法接受一个函数，返回一个值。该方法会从一个累加值开始，不断对累加值和数组中的后续元素调用该函数，知道数组的最后一个元素，最后返回累加值.(对数组求和)
let arr = [1, 2, 4, 5, 5, 7, 8, 32, 89]
const result = arr.reduce((pre,next) =>pre+next,0)
console.log(result) // 153
map()该方法和forEach类似，map和forEach方法不能跳出循环，for of可以
filter()该方法接受一个函数，对数组的每一个元素调用该函数，返回一个新的数组，不改变原数组。起到对原数组进行过滤的作用
let arr = [1, 2, 4, 5, 5, 7, 8, 32, 89]
let arrNew = arr.filter((item)=>item > 5)
console.log(arrNew) // [7, 8, 32, 89]
冒泡排序
function sort(arr){
for(let i = 0; i < arr.length; i++){
for(let j = 0; j < arr.length - i -1; j++){
if(arr[j] > arr[j + 1]){
const temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
}
}
return arr
}
// 冒泡排序优化
function sort(arr){
for(let i = 0; i < arr.length; i++){
let isGo = false
for(let j = 0; j < arr.length - i -1; j++){
if(arr[j] > arr[j + 1]){
isGo = true
const temp = arr[j]
arr[j] = arr[j + 1]
arr[j + 1] = temp
}
}
if(!isGo) break;
}
return arr
}
快速排序
function quickSort(arr){
if(arr.length < 2) return arr
const leftArr = [];
const rightArr = [];
const middleIndex = arr.length / 2;
const middle = arr.splice(middleIndex, 1)[0];
arr.map(item=>{
if(middle > item){
leftArr.push(item)
}else{
rightArr.push(item)
}
})
return [...quickSort(leftArr), ...quickSort(rightArr)]
}
