# 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 []


  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]


  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]


  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]


  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]


  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


    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


  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]


  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']


  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


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'


  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


  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]


  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 }]


  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]


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]


  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']}


  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]


  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)


|
5天前
|
JavaScript 前端开发
JavaScript基础知识-数组的遍历

13 2
|
5天前
|
JavaScript 前端开发
JavaScript基础知识-数组的练习

12 1
|
5天前
|
JavaScript 前端开发
JavaScript基础知识-数组的常用方法

5 1
|
5天前
|
JavaScript 前端开发 索引
JavaScript基础知识-数组基于索引访问

8 1
|
21小时前
|

JS中的数组有哪些常用操作函数和属性
【9月更文挑战第7天】JS中的数组有哪些常用操作函数和属性
6 1
|
12天前
|

Python进行Socket接口测试的实现

30 4
|
14天前
|

Python进行Socket接口测试的实现

11 1
|
14天前
|
SQL Java 测试技术
SpringBoot单元测试快速写法问题之PorkService 接口中的 getPork 方法的作用如何解决
SpringBoot单元测试快速写法问题之PorkService 接口中的 getPork 方法的作用如何解决
13 1
|
17天前
|
XML Web App开发 数据挖掘
Postman接口测试工具全解析：功能、脚本编写及优缺点探讨

26 1
|
2月前
|

Postman 接口测试配置 Pre-request Script
Postman 接口测试配置 Pre-request Script
97 5

DDNS