JavaScript —— JSchallenger Arrays 数组练习（测试一下你的 JS 数组基础）【专题二】

---

二、JavaScript 数组练习

数组方法查询

1. 返回数组 a 的第 n 个元素

	Test: myFunction([1, 2, 3, 4, 5], 3)     Expected 3
	Test: myFunction([10, 9, 8, 7, 6], 5)    Expected 6

代码实现：数组索引下标获取

	function myFunction(a, n) {
    
    
        return a[n - 1]
    }
    myFunction([10, 9, 8, 7, 6], 5)

2. 删除数组 a 的前三个元素，并返回结果

	Test: myFunction([1, 2, 3, 4])     Expected [4]
	Test: myFunction([99, 1, 1])       Expected []

代码实现：使用 splice() 或者 slice()

	function myFunction(a) {
    
    
        return a.splice(3)
    }
    myFunction([1, 2, 3, 4])

	function myFunction(a) {
    
    
        return a.slice(3)
    }
    myFunction([1, 2, 3, 4])

3. 提取数组 a 的后三个元素，并返回结果

	Test: myFunction([1, 2, 3, 4])     Expected [2, 3, 4]
	Test: myFunction([99, 1, 1])       Expected [99, 1, 1]

代码实现：使用 splice() 或者 slice()

	function myFunction(a) {
    
    
        return a.splice(-3)
    }
    myFunction([1, 2, 3, 4])

	function myFunction(a) {
    
    
        return a.slice(-3)
    }
    myFunction([1, 2, 3, 4])

4. 提取数组 a 的前三个元素，并返回结果

	Test: myFunction([1, 2, 3, 4])   Expected [1, 2, 3]
	Test: myFunction([99, 1, 1])     Expected [99, 1, 1]

代码实现：使用 splice() 或者 slice()

	function myFunction(a) {
    
    
        return a.splice(0, 3)
    }
    myFunction([1, 2, 3, 4])

	function myFunction(a) {
    
    
        return a.slice(0, 3)
    }
    myFunction([1, 2, 3, 4])

5. 以数组 a 和 数字 n 为参数，返回 a 的最后 n 个元素

	Test: myFunction([1, 2, 3, 4, 5], 2)  Expected [4, 5]
	Test: myFunction([1, 2, 3], 6) 		  Expected [1, 2, 3]

代码实现：使用 splice() 或者 slice()

	function myFunction(a, n) {
    
    
        return a.splice(-n)
    }
    myFunction([1, 2, 3, 4, 5], 2)

	function myFunction(a, n) {
    
    
        return a.slice(-n)
    }
    myFunction([1, 2, 3, 4, 5], 2)

6. 以数组 a 和 值 b 为参数，清除 a 中出现的所有 b，过滤后返回数组

	Test: myFunction([1, 2, 'hello'], 2)      Expected [1, 'hello']
	Test: myFunction([1, 2, '2'], '2')        Expected [1, 2]
	Test: myFunction([false, '2', 1], false)  Expected ['2', 1]

代码实现：通过 filter() 和 every() 过滤出两个数组中不相等的元素，并赋值到一个新数组中，返回这个新数组。

	function myFunction(a, b) {
    
    
        let newArr = a.filter(function (item) {
    
    
            return Array.of(b).every(function (item1) {
    
    
                return item !== item1
            })
        })
        return newArr
    }
    myFunction([1, 2, '2'], 2)

	function myFunction(a, b){
    
    
		return a.filter(num => num !== b)
	}

7. 数组的元素个数

	Test: myFunction([1, 2, 2, 4])     Expected 4
	Test: myFunction([9, 9, 9])        Expected 3

代码实现：.length

    function myFunction(a) {
    
    
        return a.length
    }
    myFunction([1, 2, 2, 4])

8. 返回数组中负值的个数

	Test: myFunction([1, -2, 2, -4])   Expected 2
	Test: myFunction([0, 9, 1])        Expected 0

代码实现：使用 filter() 过滤出小于0的值个数

	function myFunction(a){
    
    
		return a.filter(el => el < 0).length 
	}

9. 返回降序排序的数组

	Test: myFunction([1, 3, 2])      Expected [3, 2, 1]
	Test: myFunction([4, 2, 3, 1])   Expected [4,2,3,1]

代码实现：使用 sort()

	function myFunction(arr) {
    
    
        return arr.sort((a, b) => b - a)
    }
    myFunction([1, 2, 3])

10. 按字母顺序对数组元素排序，返回排好序的数组

	Test: myFunction(['b', 'c', 'd', 'a'])   Expected ['a', 'b', 'c', 'd']
	Test: myFunction(['z', 'y', 'x'])        Expected ['x', 'y', 'z']

代码实现：sort() 方法

	function myFunction(arr) {
    
    
        return arr.sort()
    }
    myFunction(['b', 'c', 'd', 'a'])

11. 以数字数组作为参数，返回数字的平均值

	Test: myFunction([10, 100, 40])       Expected 50
	Test: myFunction([-50, 0, 50, 200])   Expected 50

代码实现：使用 传统 for循环 或 reduce() 方法
reduce()：方法接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值。

	function myFunction(arr) {
    
    
		let sum = 0
		for(let i = 0; i < arr.length; i++) {
    
    
		   sum += arr[i]
		}
		return sum / arr.length
	}
	myFunction([10, 100, 40])

	function myFunction(arr) {
    
    
        return arr.reduce((acc, cur) => acc + cur, 0) / arr.length
    }
    myFunction([10, 100, 40])

12. 字符串数组为参数的函数，返回最长的字符串

	Test: myFunction(['help', 'me'])           Expected 'help'
	Test: myFunction(['I', 'need', 'candy'])   Expected 'candy'

代码实现：使用 reduce() 再使用三目运算符

	function myFunction(arr) {
    
    
        return arr.reduce((a, b) => a.length >= b.length ? a : b)
    }
    myFunction(['help', 'love'])

13. 数组中所有元素相等，返回 true，否则返回 false

	Test: myFunction([true, true, true, true])  Expected true
	Test: myFunction([1, 1, 1, 2])   	     	Expected false
	Test: myFunction(['10', 10, 10, 10])        Expected false

代码实现：使用 new Set() 获取不重复的数组，它的长度若为 1，就表明数组中所有的元素相等。

	function myFunction(arr){
    
    
		return new Set(arr).size === 1
	}
	myFunction([1, 1, 1, 2])

14. 函数接收任意数量数组，返回一个包含所有值的数组

	Test: myFunction([1, 2, 3], [4, 5, 6])         Expected [1, 2, 3, 4, 5, 6]
	Test: myFunction(['a', 'b', 'c'], [4, 5, 6])   Expected ['a', 'b', 'c', 4, 5, 6]

代码实现：使用 flat() 把数组打平。

	function myFunction(...arrays) {
    
    
        return arrays.flat()
    }
    myFunction(['a', 'b', 'c'], [4, 5, 6])

15. 以对象数组为参数，按属性 b 升序对数组排序，返回数组

	Test: myFunction([{
    
     a: 1, b: 2 }, {
    
     a: 5, b: 4 }])  Expected [{
    
     a: 1, b: 2 }, {
    
     a: 5, b: 4 }]
	Test: myFunction([{
    
     a: 2, b: 10 }, {
    
     a: 5, b: 4 }]) Expected [{
    
     a: 5, b: 4 }, {
    
     a: 2, b: 10 }]

代码实现：使用 sort() 对 b 进行排序

	function myFunction(arr){
    
    
		const sort = (x, y) => x.b - y.b
		return arr.sort(sort)
	}

16. 合并两个数组，删除重复值，并进行升序排序，返回结果数组

	Test: myFunction([1, 2, 3], [3, 4, 5])           Expected [ 1, 2, 3, 4, 5 ]
	Test: myFunction([-10, 22, 333], [-11, 5, 22])   Expected [ -11, -10, 5, 22, 333]

代码实现：

1. 用 concat() 拼接数组，再对拼接好的数组 sort() 排序，之后 new Set() 去重，最后 Array.from 转为数组。
2. 用 ... 运算符拼接数组，再对拼接好的数组 sort() 排序，之后 ...new Set() 去重，最后用 [] 括起来，得到数组。

Array.from()：从对象或可迭代对象（如Map，Set等）返回一个新数组。

Array.of()：将一组数值转换为数组。基本上可以用来替代 Array() 或 new Array()，并且不存在由于参数不同而导致的重载。

	function myFunction(a, b) {
    
    
        let res = new Set(a.concat(b).sort((a, b) => a - b))
        return Array.from(res)
    }
    myFunction([-10, 22, 333, 42], [-11, 5, 22, 41, 42])

	function myFunction(a, b) {
    
    
        return res = [...new Set([...a, ...b])].sort((x, y) => x - y)
    }
    myFunction([-10, 22, 333, 42], [-11, 5, 22, 41, 42])

17. 数组 a 和数字 b 为参数的函数，将值大于 b 的所有数组元素相加

	Test: myFunction([1, 2, 3, 4, 5, 6, 7], 2)    Expected 25
	Test: myFunction([-10, -11, -3, 1, -4], -3)   Expected 1

代码实现：

1. 使用 filter() 过滤出来数组 a 中大于数值 b 的值，再对得到的值通过 reduce() 求和。
2. 使用 reduce() 求出通过 if 判断语句筛选出来的值。

	array.reduce(function(total, currentValue, currentIndex, arr), initialValue)

1. total：必需。初始值, 或者计算结束后的返回值。
2. currentValue：必需。当前元素。
3. currentIndex：可选。当前元素的索引。
4. arr：可选。当前元素所属的数组对象。
5. initialValue： 可选。传递给函数的初始值。

	function myFunction(a, b){
    
    
		let nums = a.filter(x => x > b)
		let res = nums.reduce((acc, cur) => acc + cur)
		return res
	}
	myFunction([1, 2, 3, 4, 5, 6, 7], 2)

	function myFunction(a, b){
    
    
		return a.reduce((sum, cur) => {
    
    
			if(cur > b) return sum + cur
			return sum
		}, 0) //此处的 0是传递函数的初始值，如果不赋值 0得到的结果就是26了（因为传递参数的初始值是1）
	}
	myFunction([1, 2, 3, 4, 5, 6, 7], 2)

18. 返回最小（min）和最大（max）范围内的数字数组

	Test: myFunction(2, 10)   Expected [2, 3, 4, 5, 6, 7, 8, 9, 10]
	Test: myFunction(1, 3)    Expected [1, 2, 3]

代码实现：使用 for 循环，push() 出来满足条件的数，赋值给一个空数组。

	function myFunction(min, max){
    
    
		let arr = []
		for(let i = min; i <= max; i++){
    
    
			arr.push(i)
		}
		return arr
	}

19. 按字符串的第一个字母将其分组，返回一个对象

	Test: myFunction(['Alf', 'Alice', 'Ben'])         Expected {
    
     a: ['Alf', 'Alice'], b: ['Ben']}
	Test: myFunction(['Berlin', 'Paris', 'Prague'])   Expected {
    
     b: ['Berlin'], p: ['Paris', 'Prague']}

代码实现：通过 reduce() 方法，里面通过 toLowerCase().charAt(0) 把首字母小写。然后返回正确格式。

	function myFunction(arr) {
    
    
        return arr.reduce((acc, cur) => {
    
    
            const firstLetter = cur.toLowerCase().charAt(0)
            return {
    
     ...acc, [firstLetter]: [...(acc[firstLetter] || []), cur] }
        }, {
    
    })
    }
    myFunction(['Alf', 'Alice', 'Ben'])

20. 第一个元素是给定数字（小于等于6时赋值为0），其他元素是原始数组

	Test: myFunction([1, 2, 3], 6)    Expected [6, 1, 2, 3]
	Test: myFunction(['a','b'], 2)    Expected [0, 'a', 'b']

代码实现：

1. 条件语句，合并结果为数组，再使用 flat() 打平数组。
2. 三目运算符，配合 ... 操作符合并数组。

	function myFunction(arr, num){
    
    
		if(num > 5){
    
    
			return [num, arr].flat()
		} else {
    
    
			return [0, arr].flat()
		}
	}	
	myFunction(['a','b'], 2)

	function myFunction(arr, num){
    
    
		return [...(num > 5 ? [num] : [0]), ...arr]
	}
	myFunction(['a','b'], 2)

21. 以数组 a 和 数值 b 为参数的函数，将 n 及 n 的 倍数位处的元素保存到数组中并返回

	Test: myFunction([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3)   Expected [3, 6, 9]
	Test: myFunction([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], 1)   Expected [6, 1]

代码实现：把数组 a 存入 rest，置空的 result 数组用于存放结果。通过 for 循环遍历数组，如果数组的长度小于 n，break。如果不小于 n，在空数组中 push() 输出第 n - 1 的索引对应的数。之后通过 slice() 截取出来下一段数字序列进行再一次的遍历。

	function myFunction(a, n) {
    
    
        let rest = [...a]
        let result = []
        for (let i = 0; i < a.length; i++) {
    
    
            if (rest.length < n) break
            result.push(rest[n - 1])
            rest = rest.slice(n)
        }
        console.log(result)
    }
    myFunction([10, 9, 8, 7, 6, 5, 4, 3, 2, 1], 5)

不积跬步无以至千里 不积小流无以成江海