找出较小数

两个数

let minOf2 = (numbers) => {
    if(numbers[0] < numbers[1]){
        return numbers[0]
    }else{
        return numbers[1]
    }
}

优化一下

let minOf2 = numbers =>
    numbers[0] < numbers[1] 
        ? numbers[0] : numbers[1]

析构赋值继续优化

let minOf2 = ([a, b]) => a < b ? a : b

三个数

let minOf3 = ([a,b,c]) => {
    return minOf2([minOf2([a,b]), c])
}
或者
let minOf3 = ([a,b,c]) => {
    return minOf2([a, minOf2([b,c])])
}

四个数

let minOf4 = ([a,b,c,d]) => {
    return minOf2([a, minOf3([b,c,d])])
}

任意个数字找出最小数

let min = (numbers) => {
    if(numbers.length > 2){
        return min(
            [numbers[0], min(numbers.slice(1))]
        )
    }else{
        return Math.min.apply(null, numbers)
    }
}

这种调用办法叫递归
特点：函数不停的调用自己

排序算法

长度为2的数组排序

let sort2 = ([a,b]) => {
    if(a < b){
        return [a,b]
    }else{
        return [b,a]
    }
}

优化一下

let sort2 = ([a,b]) => 
    a < b ? [a,b] : [b,a]

长度为3的数组排序

let sort3 = (numbers) => {
    let index = minIndex(numbers)
    let min = numbers[index]
    numbers.splice(index, 1) 
    // numbers min
    return [min].concat(sort2(numbers)) 
}

长度为4的数组排序

let sort4 = (numbers) => {
let index = minIndex(numbers)
let min = numbers[index]
numbers.splice(index, 1)
return [min].concat(sort3(numbers))
}

任意长度的数组排序

let sort = (numbers) => {
    let index = minIndex(numbers)
    let min = numbers[index]
    numbers.splice(index, 1)
    return [min].concat(sort(numbers))
}

这样会陷入死循环
使用minindex

let minIndex = (numbers) =>
    numbers.indexOf(min(numbers))   

优化代码

let sort = (numbers) => {
    if(numbers.length > 2){
        let index = minIndex(numbers)
        let min = numbers[index]
        numbers.splice(index, 1)
        return [min].concat(sort(numbers))
    }else{
        return numbers[0]<numbers[1] ? numbers : numbers.reverse()
    }
}