JavaScript内置对象与数组笔记

1、什么是对象

是一个复杂数据类型, 专门用来存储数据的
会给每一个存储的数据起一个名字
创建对象的方式
字面量创建
var obj = {}
内置构造函数创建
var obj = new Object()
操作对象的语法(点语法)
增: 对象名.你要增加的名字 = 你要增加的值
删: delete 对象.你要删除的名字
改: 对象名.你要修改的名字 = 你要修改的值(原先有就是修改, 原先没有就是增加)
查: 对象名.你要查询的名字
操作对象的语法(数组关联语法)
增: 对象名[‘你要添加的名字’] = 你要添加的值
删: delete 对象名[‘你要删除的名字’]
改: 对象名[‘你要修改的名字’] = 你要修改的值
查: 对象名[‘你要查询的名字’]
两种操作语法
使用的结果没有区别, 互相可以混合着使用
只是为了实现一个需求的两种语法
var obj = {}

1、增加
obj.a = 100
obj.age = 18
obj.gender = ‘男’
obj[‘name’] = ‘Jack’

2、删除
delete obj.age
delete obj[“a”]
3、修改
obj.a = 200
obj[‘gender’] = ‘女’
4、查询
console.log(obj.gender)
console.log(obj[‘name’])
console.log(obj)
对象存储数据
var obj = {}
obj[‘name’] = ‘Jack’ // 字符串
obj.sex = true // 布尔类型
obj.age = 18 // 数值类型
obj.fn = function () { // 函数类型
console.log(‘我是存储再 obj 里面的 fn 函数’)
}
使用的时候
console.log(obj.name)
console.log(obj.age)
console.log(obj.sex)
执行函数, 就是要执行 obj 空间里面的 函数
obj 的 fn 执行
obj.fn()

2、递归函数

递归: 就是一个函数的高级使用方式 - 自己调用自己
本质:
1、 自己调用自己
2、递进去归回来
递归函数:
就是一个函数自己调用自己, 把一个有规律的问题
转换成自己和自己的前一步
注意: 一定要设计一个尽头, 不能一直递进去
写递归: 先写停的条件
递归使用:
90% ~ 95% 递归能做的事情循环也能
推荐使用循环, 不推荐使用递归
慎用!!!慎用!!!慎用!!!
死递归
function fn() {
console.log(‘fn 函数执行了一下’)
自己调用自己
fn() // 打开变成死递归了
}
fn()
递归求阶乘 4
function fn(n) {
当 数字 === 1 的时候, 结束我们递进来的过程
开始准备归回去
if (n === 1) {
return 1
}
把每一个数字的阶乘转换为求 数字 * 数字-1 的阶乘
return n * fn(n - 1)
}
var res = fn(4)
console.log(res)
斐波那契 数列
数列: 1 1 2 3 5 8 13 21 34 55 …
第一个和第二个永远是 1
第三个数字开始, 是前两个数字的和
使用递归来计算
比如: 我要求 数列的 第 6 位是什么 ? 8
求 fn(6) -> 求 fn(5) + fn(4)
fn(5)
fn(4)
fn(3)
fn(2)
fn(1)
fn(2)
fn(3)
fn(2)
fn(1)
fn(4)
fn(3)
fn(2)
fn(1)
fn(2)
停的条件: 当 n === 1 或者 n === 2 的时候
当你要求 第一位 或者 第二位 的时候
停掉开始归回去, 直接返回 1
function fn(n) {
n 表示我要求的是这个数列的 第几位 数字

递归: 就是一个函数的高级使用方式 - 自己调用自己
本质:
1、 自己调用自己
2、递进去归回来
递归函数:
就是一个函数自己调用自己, 把一个有规律的问题
转换成自己和自己的前一步
注意: 一定要设计一个尽头, 不能一直递进去
写递归: 先写停的条件
递归使用:
90% ~ 95% 递归能做的事情循环也能
推荐使用循环, 不推荐使用递归
慎用!!!慎用!!!慎用!!!
死递归
function fn() {
console.log(‘fn 函数执行了一下’)
自己调用自己
fn() // 打开变成死递归了
}
fn()
递归求阶乘 4
function fn(n) {
当 数字 === 1 的时候, 结束我们递进来的过程
开始准备归回去
if (n === 1) {
return 1
}
把每一个数字的阶乘转换为求 数字 * 数字-1 的阶乘
return n * fn(n - 1)
}
var res = fn(4)
console.log(res)
斐波那契 数列
数列: 1 1 2 3 5 8 13 21 34 55 …
第一个和第二个永远是 1
第三个数字开始, 是前两个数字的和
使用递归来计算
比如: 我要求 数列的 第 6 位是什么 ? 8
求 fn(6) -> 求 fn(5) + fn(4)
fn(5)
fn(4)
fn(3)
fn(2)
fn(1)
fn(2)
fn(3)
fn(2)
fn(1)
fn(4)
fn(3)
fn(2)
fn(1)
fn(2)
停的条件: 当 n === 1 或者 n === 2 的时候
当你要求 第一位 或者 第二位 的时候
停掉开始归回去, 直接返回 1
function fn(n) {
n 表示我要求的是这个数列的 第几位 数字
1、先写停的条件
if (n === 1 || n === 2) {
表示要得到前两位, 一定是 1
return 1
}
2、写一个递归进去的条件
return fn(n - 1) + fn(n - 2)
}
var res = fn(6) // 8
console.log(res)
var res2 = fn(10)
console.log(res2)
递归复习
递归: 一个函数自己调用自己, 递进去归回来
求阶乘: 4!
4 * 3!
3 * 2!
2 * 1!
因为 n 的阶乘就是 从 n * … * 1
所以当 n 到达 1 的时候, 就不要再继续向下了
因为 1! 就是 1
所以当 n 到达 1 的时候, 直接返回 1
只要没有到达 1, 那么就返回 n * (n-1)!
准备一个求阶乘的函数
function fn(n) {} // n 传递是几, 就是就 几 的阶乘
24 -> 求 4!
4 * 6 -> 4 * 3!
3 * 2 -> 3 * 2!
2 * 1 -> 2 * 1!
fn(1) -> return 1
准备一个函数, 接收一个参数, 参数是几就是求几的阶乘
function fn(n) {
当 n === 1 的时候, 表示求 1 的阶乘, 那么我们直接返回 1
if (n === 1) {
return 1
}
当 n !== 1 的时候, 把 n! 变成 n * (n-1)!
return n * fn(n - 1)
}
var res = fn(4)
console.log(res)
递归求 斐波那契 数列
数列: 1 1 2 3 5 8 13 21 34 55 …
第一位和第二位一定 1
第三位开始每一位都是前两位的 和
当你需要求 第六位 是什么的时候
转换成求 第五位 + 第四位
求第五位 -> 求第四位 + 第三位
…
求第三位 -> 求第二位 + 第一位
1 1
当我们求数里第 n 位是什么的时候
一层一层的递归进去
当 n === 1 或者 n === 2 的时候, 直接返回 1, 因为前两位都是 1
当 n !== 1 也 n !== 2 的时候, 求 n-1 一位 + n-2 一位
准备一个函数, 接收一个参数, 参数是几就表示你要求第几位的数是多少
function fn(n) {
n 是几, 就要得到第几位是什么数字
写停的条件
if (n === 1 || n === 2) {
当你要求第一位和第二位的时候, 我直接给你 1
return 1
}
否则, 你既不是求 第一位, 也不是求 第二位
那么就返回 n-1 位 + n-2 位
return fn(n - 1) + fn(n - 2)
}
var res = fn(10)
console.log(res)
fn(4) 2 + 1 = 3
fn(3) 得到结果 1 + 1 = 2
fn(2) 1
fn(1) 1
fn(2) 得到结果 1

3、数组数据类型

数组:
就是一个存储数据的空间, 里面会把你存储进去的所有数据
按照顺序依次排好, 每一个数据给一个编号(索引/下标)
编号从 0 开始
数组的创建方式:
\1. 字面量创建
var arr = []
\2. 内置构造函数创建
var arr = new Array()
创建数组的时候, 两种方式的使用
\1. 字面量
创建空数组: var arr = []
创建一个带有数据的数组: var arr = [数据1, 数据2, 数据3, 数据4, …]
\2. 内置构造函数
创建空数组: var arr = new Array()
创建一个包含 多个 内容的数组: var arr = new Array(数据1, 数据2, 数据3, …)
创建一个包含 一个 内容的数组: var arr = new Array(数据1但不能是数字)
创建一个 指定长度 没有内容的数组: var arr = new Array(数字表示长度)
总结: 当你使用内置构造函数这个方法创建数组的时候
如果不传递参数, 那么就是空数组
如果传递一个参数
是一个数字的话, 那么表示数组的长度
不是一个数字的话, 那么表示数组里面的一个数据
如果传递多个参数
每一个参数都表示数组里面的一个数据
创建带有数据的数组
1、字面量
var arr = [100, 200, true, ‘hello world’, function () {}]
console.log(arr)
2、内置构造函数创建一个有多个数据的数组
var arr = new Array(300, 400, false, ‘你好 世界’)
console.log(arr)
3、内置构造函数创建一个只有一个数据的数组
var arr = new Array(‘nihao’)
console.log(arr)
4、 内置构造函数创建一个指定长度的数组
var arr2 = new Array(20)
console.log(arr2)
创建空数组
1、字面量创建数字
var arr = []
console.log(arr)
2、内置构造函数创建数组
var arr = new Array()
console.log(arr)
数组的索引和length
索引:
就是数组里面每一个数据的 “编号”
从 0 开始递增
也是一个读写的属性
读: 获取第 n 位的数据是什么
如果数组有第 n 位, 那么就是第 n 位的数据
如果数组没有第 n 位, 那么就是 undefined
写: 写如数组第 n 位是什么数据
如果数组有第 n 位, 那么就是把第 n 位的数据修改一下
如果没有第 n 位, 就是加一个第 n 位
length:
表示数组的长度, 也就是数组里面有多少个数据
是一个动态的属性, 可以读, 也可设置
读: 获取到数组的长度
写: 设置数组的长度
如果比原先还小, 那么后面的就算是删除了
如果比原先还大, 那么多出来的就都是 空(empty)
length 的读写
var arr = [‘hello’, ‘world’, ‘你好’, ‘世界’]
console.log(arr.length) // 读数组的长度
arr.length = 2 // 把数组的 length 改变成 2
arr.length = 100 // 把数组的 length 改变成 100
console.log(arr)
索引的 读写
var arr = [‘hello’, ‘world’, ‘你好’, ‘世界’]
console.log(arr[0]) // 获取数组中索引为 0 的数据
console.log(arr[100]) // 获取数组中索引为 0 的数据
arr[1] = ‘后来换的’ // 把 arr 数组的索引 1 位置数据写成 ‘后来换的’
arr[100] = ‘新来的’ // 把 arr 数组的索引 100 位置数据写成 ‘新来的’
console.log(arr)

4、数据类型之间的存储区别

基本数据类型 和 复杂数据类型 之间存储上有什么区别
数据类型
基本数据类型
Number
String
Boolean
Undefined
Null
复杂数据类型
Function 函数
Object 对象
Array 数组
内存空间
我们所有的数据都是存储再内存空间中的
浏览器的内存空间被分为了两个部分
1、栈内存
2、堆内存
都是用来存储数据的
数据存储
1、基本数据类型就是直接存储在 栈内存 里面的
2、复杂数据类型
数据存储在 堆内存 里面, 会有一个空间地址
地址存储在 栈内存 里面的变量身上
// 基本数据类型, 存储在栈里面
var n1 = 100
var s1 = ‘abc’
var b1 = true
// 复杂数据类型, 数据在堆里面, 地址在栈里面
var obj = {
name: ‘Jack’,
age: 18,
gender: ‘男’
}
var arr = [10, 20, 30]
function fn() {
console.log(123)
}

5、数据类型之间的赋值区别

基本数据类型 和 复杂数据类型 赋值的时候的区别
1、基本赋值
把一个变量的值赋值给另外一个变量
基本数据类型赋值之后, 两个变量没有关系了
复杂数据类型赋值之后, 两个变量操作同一个空间
一个修改空间里面的数据
另一个跟着修改
2、函数的形参和实参的交互
函数的形参: 就是定义在函数内部的私有变量
函数的实参: 就是在调用的时候给形参赋值的
实参给形参赋值, 和基本变量赋值的规则是一摸一样的
// 函数实参赋值复杂数据类型
var obj = { name: ‘Jack’ }
function fn(o) {
o.name = ‘Rose’
console.log(o.name) // Rose
}
fn(obj) // 把 obj 存储的内容赋值给了形参 o
这里 obj 存储的就是一个指向空间的地址
赋值给 o 的也是一个指向空间的地址
赋值以后, 全局变量 obj 和函数内部形参 o 指向的是同一个空间
console.log(obj.name) // Rose
函数实参赋值基本数据类型
var n = 100
function fn(a) {
a = 200
console.log(a) // 200
}
fn(n) // 把变量 n 的值赋值给了函数的形参 a
console.log(n) // 100
复杂数据类型的赋值
var obj = { name: ‘Jack’ }
var obj2 = obj // 把 obj 存储的内容赋值给了 obj2 这个变量
obj2.name = ‘Rose’
console.log(obj.name) // Rose
console.log(obj2.name) // Rose
基本数据类型的赋值
var a = 10
var b = a // 把变量 a 的值赋值给变量 b
b = 20
console.log(a) // 10
console.log(b) // 20
for 和 for … in 循环
for 循环
因为数组的索引是 0 ~ n 排列
for 循环也可以得到一组 0 ~ n 的数字
for 循环就可以循环遍历数组
for … in 循环
语法: for (var key in 对象) { 重复执行的代码 }
key 是你自己起的一个变量名
在每一次执行的时候, 分别是对象中每一个成员的 “名字”
in 在 … 里
对象 就是你要遍历的对象
{} 是重复执行的代码
会根据对象中有多少个成员执行多少回
注意: for … in 循环也能遍历数组, 只是我们一般不这样用
for … in 循环
var obj = {
a: 100,
name: ‘Jack’,
age: 18,
b: 200,
c: 500
}
for … in 循环遍历对象
表示我要遍历的是 obj 这个对象
for (var key in obj) {
obj 这个对象有多少个成员, 这里的代码就执行多少回
console.log(‘我执行了’ + ’ — ’ + key)
利用这个 key 来遍历对象中的每一个成员
obj[‘你要查询的名字’]
console.log(key + ’ 成员的值是 : ’ + obj[key])
在这个循环里面
第一次的时候 key 就是 ‘a’
第二次的时候 key 就是 ‘name’
第三次的时候 key 就是 ‘age’
第四次的时候 key 就是 ‘b’
第五次的时候 key 就是 ‘c’
}
for 循环遍历数组
var arr = [‘hello’, ‘world’, ‘你好’, ‘世界’]
遍历数组
我需要的索引 0 1 2 3
数组的 length === 4
for (var i = 0; i < arr.length; i++) {
i 得到的就是 0 1 2 3
console.log(arr[i])
当 i === 0 的时候, 就是 arr[0]
当 i === 1 的时候, 就是 arr[1]
}

6、数组的常用方法

专门用来操作数组的方法
1、push() 方法
作用: 向数组的后面追加数据
语法: 数组.push(你要追加的数据1, 你要追加的数据2, …)
返回值: 追加完毕数据以后, 数组的长度
2、pop() 方法
作用: 删除数组的最后一个数据
语法: 数组.pop()
返回值: 被删除的那个数据
3、unshift() 方法
作用: 向数组的最前面添加数据
语法: 数组.unshift(你要添加的数据1, 你要添加的数据2, …)
返回值: 添加完毕数据以后, 数组的长度
4、shift() 方法
作用: 删除数组的最前面一个数据
语法: 数组.shift()
返回值: 被删除的那个数据
5、reverse() 方法
作用: 是反转数组
语法: 数组.reverse()
返回值: 反转后的数组
6、sort() 方法
作用: 给数组进行排序
语法:
1、数组.sort() -> 按照一位一位来看进行排序的
2、数组.sort(function (a, b) { return a - b }) -> 按照从小到大升序排列
数组.sort(function (a, b) { return b - a }) -> 按照从大到小降序排列
返回值: 排序好的数组
3、splice() 方法
作用:
1、截取数组
2、截取数组以后, 在截取位置替换新的内容
语法:
1、数组.splice(从哪个索引开始, 截取多少个)
2、数组.splice(从那个索引开始, 截取多少个数据, 你要填充的数据1, 你要填充的数据2, …)
从哪个索引开始截取, 从哪个索引开填充
返回值: 被截取出来的内容(返回值一定是一个数组)
不管你截取多少个数据, 返回的数组里面就有多少个被截取出来的数据
如果你一个都不删除, 返回的就是一个空数组
8、slice() 方法
作用: 在不改变(影响)原始数组的基础上, 从数组里面提取出一段内容
语法:
1、数组.slice(从哪一个索引开始, 到哪一个索引结束) - 包前不包后
2、数组.slice(从哪一个索引开始, 负整数) - 包前不包后
负整数 等价于 (数组的length + 负整数)
返回值: 你提取出来的数据(一定是一个数组)
如果你有提取数据, 那么数组里面就是你提取的数据
如果你没有提取数据, 那么数组里面就是空数组
9、concat() 方法
作用: 解释把多个数组连接在一起, 变成一个新的数组, 不影响原始数组
语法: 数组.concat(你要连接的数据或者数组1, 你要连接的数据或者数组2, …)
返回值: 把所有的参数都连接到第一个数组身上, 返回一个连接好的新数组
10、 join() 方法
作用: 是把数组里面的每一个数据组合起来, 变成一个字符串
语法: 数组.join(‘你要连接每一个数据的连接内容’)
参数: 如果你不传递参数, 默认使用 逗号(,) 进行连接
返回值: 一定是一个字符串
就是用你提供的连接内容来连起来以后的字符串
var arr = [‘hello’, ‘world’, ‘你好’, ‘世界’]
1、 push()
var res = arr.push(100, 200, true)
console.log('返回值是 : ’ + res) // 看一下返回值
console.log(arr) // 看一下我这个数组
2、pop()
var res = arr.pop()
console.log('返回值是 : ’ + res) // 看一下返回值
console.log(arr) // 看一下我这个数组
3、unshift()
var res = arr.unshift(100, 200, false)
console.log('返回值是 : ’ + res) // 看一下返回值
console.log(arr) // 看一下我这个数组
4、shift()
var res = arr.shift()
console.log('返回值是 : ’ + res) // 看一下返回值
console.log(arr) // 看一下我这个数组
5、reverse()
var res = arr.reverse()
console.log(‘返回值是 : ’ , res) // 看一下返回值
console.log(arr) // 看一下我这个数组
var arr = [1, 5, 2, 8, 11, 22, 13, 54, 32, 7, 6, 21, 9]
6、sort()
var res = arr.sort()
console.log(res)
console.log(arr)
var res = arr.sort(function (a, b) { return a - b })
console.log(res)
console.log(arr)
var res = arr.sort(function (a, b) { return b - a })
console.log(res)
console.log(arr)
var arr = [‘hello’, ‘world’, ‘你好’, ‘世界’]
7、splice()
var res = arr.splice(2, 0)
console.log(res) // 看一下返回值
console.log(arr) // 看一下原数组
var res = arr.splice(1, 1, ‘新来的’, ‘新来的2’, ‘新来的3’)
console.log(res) // 看一下返回值
console.log(arr) // 看一下原数组
var res = arr.splice(1, 2, ‘新来的’, ‘新来的2’, ‘新来的3’)
console.log(res) // 看一下返回值
console.log(arr) // 看一下原数组
var res = arr.splice(1, 0, ‘新来的’, ‘新来的2’, ‘新来的3’)
console.log(res) // 看一下返回值
console.log(arr) // 看一下原数组
var arr = [‘hello’, ‘world’, ‘你好’, ‘世界’]
8、slice()
var res = arr.slice(1, 3) // 表示从索引 1 开始, 到索引 2 结束(不包含索引2)
console.log(res)
console.log(arr)
var res = arr.slice(1, -1) // 表示从索引 1 开始, 到索引 3 结束(不包含索引3)
写的是 -1 等价于 4 + -1 === 3
和你写 arr.slice(1, 3) 是一摸一样的
console.log(res)
console.log(arr)
var arr = [‘hello’, ‘world’, ‘你好’, ‘世界’]
9、concat()
var res = arr.concat([1, 2, 3], [4, 5, 6], true, false, 100, 200)
console.log(res) // 看一下返回值
console.log(arr) // 看一下原数组
10、join()
var arr = [‘hello’, ‘world’, ‘你好’, ‘世界’]
var res = arr.join(’ — ')
console.log(res) // 看一下返回值
console.log(arr) // 看一下原始数组

递归: 就是一个函数的高级使用方式 - 自己调用自己
本质: