# 四.数据类型
前言
- 基本数据类型:number、string、boolean、undefined、null
- 引用数据类型:object、array、function
# 1.number
# 1.1 类型转换
# 1.2 常用方法
# 2.string
# 2.1 类型转换
# 2.2 常用方法
# 2.2.1 replace
# 2.2.2 slice
# 3.boolean
# 3.1 类型转换
# 3.2 常用方法
# 4.undefined
# 4.1 类型转换
# 4.2 常用方法
# 5.null
# 5.1 类型转换
# 5.2 常用方法
# 6.object
# 6.1 字面量
let obj = {}
1
let obj = new Object()
1
# 6.1 类型转换
# 6.2 常用方法
# 6.2.1 assign
- 合并数据
var a = { key: 1 }
Object.assign(a, { key: 2, o: 3 })
1
2
2
# 6.2.2 keys
# 6.2.3 value
# 7.array
# 7.1 字面量
let arr = []
1
let arr = new Array()
1
# 7.1 类型转换
# 7.2 常用方法
# 7.2.1 forEach
遍历数组中的每一项
- 1.数组中有几项，那么我们传递进去的匿名回调函数就需要执行几次
var ary = [12, 3, 4, 5, 6]
ary.forEach(function () {
console.log("ok")
})
1
2
3
4
2
3
4
2.每一次执行匿名函数的时候，还给其传递了三个参数值:数组中的当前项 item，当前项的索引 index，原始的数组 input
3.理论上我们的方法是没有返回值的，仅仅是遍历数组中的每一项，不对原来的数组进行修改，但是我们可以通过数组的索引来修改原来的数组
var ary = [12, 3, 4, 5, 6]
var res = ary.forEach(function (item, index, input) {
input[index] = item * 10
})
1
2
3
4
2
3
4
- 4.实现原理
Array.prototype.forEach = function (fn) {
for (let i = 0; i < this.length; i++) {
fn(this[i], i)
}
}
;[1, 2, 3].forEach((item, index) => {
console.log(item, index)
})
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
# 7.2.2 map
- 1.map 的回调函数中支持 return 返回值
var ary = [12, 3, 4, 67, 8]
var res = ary.map(function (item, index, input) {
return item * 10
})
1
2
3
4
2
3
4
//匿名回调函数的this是window
var obj = { name: 10 }
var ary = [12, 3, 4, 67, 8]
var res = ary.map(
function (item, index, input) {
return this
}.call(obj)
) //undefined
var res = ary.map(
function (item, index, input) {
return this
}.bind(obj)
)
//不管是forEach还是map都支持两个参数，第二个参数是匿名函数的this
var res = ary.map(function (item, index, input) {
return this
}, obj)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
- 2.实现原理
Array.prototype.map = function (fn) {
let arr = []
for (let i = 0; i < this.length; i++) {
arr.push(fn(this[i], i))
}
return arr
}
let ary = [1, 2, 3].map((item) => {
return item * 2
})
console.log(ary)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# 7.2.3 reduce
- 1.返回的结果是叠加后的结果，函数的返回结果会作为下一次循环的 prev
let result = [1, 2, 3, 4, 5].reduce((prev, next, currIndex, ary) => {
if (ary.length - 1 === currIndex) {
return (prev + next) / ary.length
}
return prev + next
}, 0)
console.log(result)
let total = [{ price: 10 }, { price: 20 }, { price: 30 }].reduce(
(prev, next, currIndex, ary) => {
return prev.price + next.price
},
0
)
console.log(total)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3
4
5
6
7
8
9
10
11
12
13
14
15
- 2.数组展平
let flat = [
[1, 2, 3],
[4, 5, 6],
].reduce((prev, next, index, ary) => {
return [...prev, ...next]
})
console.log(flat)
1
2
3
4
5
6
7
2
3
4
5
6
7
- 3.实现原理
Array.prototype.myReduce = function (fn, prev) {
for (let i = 0; i < this.length; i++) {
if (typeof prev === "undefined") {
prev = fn(this[i], this[i + 1], i + 1, this)
++i
} else {
prev = fn(prev, this[i], i, this)
}
}
return prev
}
let total = [1, 2, 3].myReduce((prev, next, currIndex, ary) => {
return prev + next
}, 0)
console.log(total)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 7.2.4 filter
- 1.过滤数据，如果返回 true 表示留下 返回 false 表示删除
let arr = [1, 2, 3]
let newArr = arr.filter((item) => {
return item > 2
})
console.log(newArr)
1
2
3
4
5
2
3
4
5
# 7.2.5 some
- 1.找到后返回 true
let s = [1, 2, 3].some((item) => {
return item === 2
})
console.log(s)
1
2
3
4
2
3
4
# 8.function
# 8.1 函数参数
# 8.1.1 params
# 8.1.2 arguments
function fn() {
console.log(arguments)
}
fn(111)
1
2
3
4
2
3
4