01-对象(Object)----复杂数据类型----可以看作一个‘盒子’，里面存放无序的数据

一、对象的创建

1.字面量形式创建

var obj = {}

2.通过内置的构造函数创建

var obj = new Object()-----new有空格 Object首字母大写

注：对象内每个键值对之间用 , 分隔

二、对象数据类型的基本操作(增删改查)

正常使用的时候，一般都是使用点语法居多

点语法：

增：对象名.键名 = 值
删：delete 对象名.键名
改：对象名.键名 = 值
查：对象名.键名------如果对象没有这个键名，返回undefined

数组关联语法(中括号语法)：

增：对象名['键名'] = 值
删：delete 对象名['键名']
改：对象名['键名'] = 值
查：对象名[‘键名’]

两个语法的区别：

当键名是符合变量命名不规则和规范的名称时，两个没有区别
操作不符合变量命名规则和规范的(带有纯数字或特殊符号)名称，只能用数组关联法
涉及变量相关的时候，只能使用数组关联语法

var obj = {
    name: 'wang5',
    100: 'qwer',
    '@': 'df'
}
var num = 'name'
console.log(obj[num])

三、对象的遍历 (for in 循环)

关键字 in

语法：字符串 in 对象名

结果：布尔值

true：表示该字符串是该对象内的某一个 key

false: 表示该字符串不是该对象内的key

for in 循环

//语法：
for (var 变量 in 对象名) {
    //有多个对象执行多少回
}

注：随着循环，变量分别表示对象内的每一个key

随着循环，obj[变量] 分别表示对象内的每一个值 value

02-数组数据类型--Array---一般存储用以数据类型

一、如何创建数组？

1.字面量

var arr = [] ---创建一个变量内部存储一个空数组

2.内置构造函数

var arr = new Array()

创建有数据的数组

var arr = new Array (数1，数2，.......)

创建指定长度的数组

var arr = new Array(数字) ------数据全部使用 empty 填充

二、数组内数据的排序

数组内所有数据是按顺序排序的----每一个数据有一个属于自己的下标(索引)(index)

索引：从 0 开始，依次 +1

结论：数组的最后一个数据的索引，必然是长度 -1 (lenght - 1)

三、数组的基本操作

length属性：

读：

语法：数组名.length

得到：该数组的长度

写：

语法：数组.length = 数字

得到：数字小于 length：从末尾开始删除

大于 length： empty 补齐

索引属性

读：

语法：数组.[索引]

得到：该数组有索引位置

没有缩影位置----undefined

写：

语法:数组[索引] = 值

结果:数组内有该索引，修改该索引位置的数据，设置的索引和length一样，一一向数组内追加数据，设置的索引大于 length，中间空余用empty补齐

四、数组的遍历

var arr = [6,7,8,9,10]
for (var i = 0; i < arr.length; i++) {
    //随着循环，i表示每一个索引
    console.log(arr[i])
}

五、数组练习

// 1. 给出一个数组, 求出数组中 所有数据累加的和
var arr = [1, 2, 3, 4, 5]   // 15
var sum = 0   // 累加
for (var i = 0; i < arr.length; i++) {
    console.log(i)       // 所有下标(索引)
    console.log(arr[i])     // 数组 所有的成员
    sum += arr[i]
}
console.log(sum)    // 15

// 2. 找出数组中, 最大值
var arr = [2, 3, 5, 6, 1, 4, 9]    // 9

var sum = 0 // 用于存储数组中最大值
for (var i = 0; i < arr.length; i++) {
    if (arr[i] > sum) {
        sum = arr[i]
    }
}
console.log(sum)    // 9

// 3. 需求: 将数组第一位 和 第二位 交换位置
var arr = [1, 2, 3]
var temp = arr[0]   // 将数组的第一项  保存给变量 temp, 所以 temp == 1
arr[0] = arr[1]     // 将数组的第二项, 放到 第一个位置
arr[1] = temp
console.log(arr)

六、排序算法--冒泡

逻辑：

拿到数组内当前一个和后一个进行比较，如果前一个比后一个大，那么交换位置。
遍历数组，从头到尾依次做这个事情
把步骤2重复 length - 1 一遍

口诀：-----只会更快的写出来，对了解逻辑没有帮助

双层for循环，一层减一个里层减外层，变量相交换

var arr =[9, 3, 6, 2, 4, 1, 8, 5, 7]
for (i=0;i<arr.length-1;i++) {
    for (j=0;j<arr.length-1-i;j++ ) {
        if (arr[j] > arr[j + 1]) {
            var tmep = arr[j]
            arr[j] = arr[j + 1]
            arr[j + 1] = tmep
        }
    }
}
console.log('处理完的数组：',arr)

七、选择排序

逻辑：

找到数组内最小数字的索引，把找到的数与[0]位置的数据交换
跳过[0]以后，重复步骤1

注意：不要过多关注数据，需要关注索引

规律：	第几轮	最小索引	循环开始	和谁交换
j == 0	1	0	1	0
j == 1	2	1	2	1
j == 2	3	2	3	2

//选择排序
var arr = [9,3,6,2,4,1,8,5,7]
console.log('排序前：',arr);
for (i = 0; i < arr.length - 1; i++) {
    var maxIndex = i //假设[i]的位置数值最小
    for (j = i+1;j<arr.length;j++ ) {
        if (arr[i] > arr[j]){
            var tmp = arr[j]
            arr[j] = arr[i]
            arr[i] = tmp
        }
    }
}
console.log('排序后',arr);

数组常用方法Ⅰ

push()

语法: 数组.push(要插入的数据)

作用: 向数组的末尾添加数据

返回值: 追加数据后, 数组最新的长度

// 1. push
var num = arr.push(100)
console.log(arr)    // [1, 2, 3, 100]
console.log(num)    // 4

pop()

语法: 数组.pop()

作用: 删除数组最后一条数据

返回值: 被删除的数据

// 1. pop
var num = arr.pop()
console.log(arr)    // [1, 2]
console.log(num)    // 3

unshift()

语法: 数组.unshift(数据)

作用: 向数组的开头添加数据

返回值: 追加数据后, 数组最新的长度

// 2. unshift
var num = arr.unshift(666)
console.log(arr)    // [666, 1, 2, 3]
console.log(num)    // 4

shift()

语法: 数组.shift()

作用: 删除数组第一条数据

返回值: 被删除的数据

// 2. shift
var num = arr.shift()
console.log(arr)    // [2, 3]
console.log(num)    // 1

数组常用方法Ⅱ

reverse()

语法:数组.reverse()

作用:反转数组

返回值：反转以后的数组

var arr1 = arr.reverse()
console.log(arr1)

sort()

语法:

数组.sort()-------按照每一个数据的一位一位进行排序 acreⅡ
数组.sort(function (a,b) {a - b})-----按照数组的大小排序---升序
数组.sort(function (a,b) {b - a})-----按照数组的大小排序----降序

作用:对数组内的数据进行排序

返回值:排序后的数组

var arr1 = arr.sort()
console.log(arr1)

var arr1 = arr.sort(function (a, b) {return a - b})
console.log(arr1)

var arr1 = arr.sort(function (a, b) {return b - a})
console.log(arr1)

splice()

语法:1.数组.splice(开始索引，多少个)

2.数组.splice(开始索引，多少个，插入数据1，插入数据2，······)

作用:截取(剪切)数组部分内容，并选择性插入

返回值:必然是一个新数组——新数组内包含截取(剪切)出来的部分内容

var arr1 = arr.splice(1, 3)
console.log(arr1)
var arr1 = arr.splice(1, 3, 'n', 'w', 'e', 'hhh')
console.log('截取后的 arr: ', arr)
console.log('arr1: ', arr1)

slice()

语法：数组.slice(开始索引，结束索引)

包前不包后，包括开始索引位置数据，但不包括结束索引
可以填写负整数，表示倒数第几个(其实就是 length + 负整数)
如果不传递第二个参数，默认是length(一直到最后)
如果不传递第一个参数，默认是 0

作用：复制数组的部分内容

返回值:复制出来的部分内容组成的新数组

var arr1 = arr.slice(1, 3)
console.log('slice 处理后的数组arr: ', arr)
console.log(arr1)     // 2  1

var arr1 = arr.slice(1, -2)    // -1  相当于 length - 1    ---> 7
console.log(arr1)   // [2, 1, 4, 5, 100]

var arr1 = arr.slice(4) // 如果 不传递第二个参数, 默认从开始下标复制到数组最后
console.log(arr1)   // [5, 100, 1000, 101]

var arr1 = arr.slice()
console.log(arr1)   // [3~101]

splice 和 slice 的差异 (面试题)

参数含义不同
splice 相当于剪切，所以会改变原数组
slice 相当于复制，所以不会改变原数组

数组常用方法Ⅲ

concat()

语法:原始数组.concat(数组1，数组2，······)

作用:进行数组拼接，把参数的所有数据或者数据拼接在原始数组上。

返回值:拼接好的数组

var arr1 = arr.concat([4, 5, 6], 666, 'a', true)
console.log('拼接完成后的数据: ', arr1)

join()

语法:数组.join()

作用:使用连接符，把数组内的数据链接成字符串

返回值:连接好的数组

var arr1 = arr.join('\')
console.log(arr1)

indexOf()

语法:数组.indexOf(要检查是数组)

数组.indexOf(要检查的数据，开始索引)

作用:从前到后检索该数据第一次在数组中出现的位置

返回值:如果在数组内找到该数据，返回该数据的位置，没有找打返回 -1

var arr1 = arr.indexOf(2)
console.log(arr1)   // 1
var arr2 = arr.indexOf(200)
console.log(arr2)   // -1
var arr3 = arr.indexOf(2, 2)
console.log(arr3)   // 4

lastIndexOf()

语法:数组.lastIndexOf(要检查的数据)

数组.lastIndexOf(要检查的数据，开始索引)

作用:从后到前检索该数据第一次在数组中出现的位置

返回值:如果在数组内找到该数据，返回该数据的位置，没有找打返回 -1

var arr1 = arr.lastIndexOf(2)
console.log(arr1)   // 4
var arr2 = arr.lastIndexOf(2, 1)
console.log(arr2)   // 1
var arr3 = arr.lastIndexOf(200)
console.log(arr3)   // -1

数组常用方法Ⅳ---数组的遍历

forEach()

在开发中，常用第一个参数第二个看情况

语法:数组.forEach(function (item,index,origin) {})

item:数组的每一项(数组的每一个值)
index:数组每一个项对应的下标
origin:原始数组

作用:遍历数组

返回值:没有

注意:* 在回调函数内，手写return也不会有返回值*

var arr1 = arr.forEach(function (item, index, o) {
    console.log(item, '在数组中的下标 ---> ', index, '原始数组: ', o)
return 100   // 写了也没用, forEach 不会有返回值
})
console.log('forEach 的返回值: ', arr1)

arr.forEach(function (item, index) {
    console.log(item, index)
})

map()

语法:数组.map(function (item,index,origin) {})

item:数组的每一项(数组的每一个值)
index:数组每一个项对应的下标
origin:原始数组

作用:映射数组

返回值:和数组长度一样的数组，只不过内部数据经过映射加工

var arr1 = arr.map(function(item, index, o) {
    console.log(item, '在数组中的下标 ---> ', index, '原始数组: ', o)
    return item / 100
})
console.log('数组 arr1 ---> ', arr1)

filter()

语法:数组.filter(function(item, index, origin) {})

item:数组的每一项(数组的每一个值)
index:数组每一个项对应的下标
origin:原始数组

作用:过滤

返回值:一个新数组----存放的是原始数组满足条件的内容

以return的形式书写过滤条件

var res = arr.filter(function (item) {
    return item > 300
})
console.log('返回值 : ', res)

find()

语法:数组.find(function(item, index, origin) {})

item:数组的每一项(数组的每一个值)
index:数组每一个项对应的下标
origin:原始数组

作用:查找满足条件的第一项

返回值:如果数组内有满足的条件的数据，那就是第一个满足的条件的数据

如果数组内没有满足条件的数据，返回undefined

以return的形式书写过滤条件

var res = arr.find( function(item) {
    return item % 10 ===0
})
console.log('返回值'，res)

findIndex()

语法:数组.findIndex(function(item, index, origin) {})

item:数组的每一项(数组的每一个值)
index:数组每一个项对应的下标
origin:原始数组

作用:在原始数组内查找满足田间第一项的索引

返回值:如果数组内有满足的条件的数据，那就是第一个满足的条件的数据

如果数组内没有满足条件的数据，返回 -1

以return的形式书写过滤条件

var res = arr.findIndex( function(item) {
    return item % 10 ===0
})
console.log('返回值'，res)

every()

语法:数组.every(function(item, index, origin) {})

item:数组的每一项(数组的每一个值)
index:数组每一个项对应的下标
origin:原始数组

作用:判断数组内是否每一个都满足条件

返回值:布尔值

true:每一个都满足
false:至少一个不满足

注：判断条件以return形式书写

var res = arr.every( function(item) {
    console.log(item)
    return item >= 100
})
console.log('返回值'，res)

some()

语法:数组.some(function(item, index, origin) {})

item:数组的每一项(数组的每一个值)
index:数组每一个项对应的下标
origin:原始数组

作用：判断数组内某一个满足条件

注：判断条件以return形式书写

var res = arr.some( function(item) {
    return item > 500
})
console.log('返回值'，res)

reduce()

语法:数组.filter(function(prev.item, index, origin) {},init)

prev:初始值或上一次运算结果

作用:叠加

返回值:最终叠加的结果

注:prev 的值，传递了init,就是init的值，没有就是 [0] 的值

注:传递了init,循环 length 次，没有传递,循环 length - 1

var arr = [100,200,300,400,500]
var res = arr.reduce (function(prev,item){
    return prev + item
},0)
console.log(res)     //返回值：1500
/*
      reduce 也会遍历数组
        第一次:
          => prev === 0
          => item === 100
          => return 100
        第二次:
          => prev === 100
          => item === 200
          => return 300
        第三次:
          => prev === 300
          => item === 300
          => return 600
        第四次:
          => prev === 600
          => item === 400
          => return 1000
        第五次:
          => prev === 1000
          => item === 500
          => return 1500
      结束
 */

var arr = [100,200,300,400,500]
var res = arr.reduce (function(prev,item){
    return prev + item
},'')
console.log(res)     //返回值：100200300400500

八、数组塌陷

塌陷:当你删除数组中的数据, 从删除位置向后的数据, 索引会向前递进

困扰：当你删除以后, 还要继续遍历数组的时候, 会少东西

解决：方案一：倒着循环(倒着遍历)

for (i = arr.length - 1;i >= 0;i--) {
    arr.splice(i,1)
}
console.log(arr)

方案二：i--

for (i = 0; i< arr.length; i++) {
    arr.splice(i,1)
    i--
}
console.log(arr)

九、数组去重

目的:去除数组中的重复项

方案一：1.遍历 2.第一个跟后面的所有对比，一样的话删掉后面的

var arr = [ 1, 1, 1, 1, 1, 1, 4, 2, 3, 2, 1, 2, 3, 4, 2, 1, 2, 3, 4 ]
for (i = 0;i < arr.length;i++) {
    var res = arr.indexOf(arr[i],i+1) //res 返回值只能是 索引值 或者 -1
    if (res !== -1) {
        arr.splice(res,1)
        i--
    }
}

方案二：1.排序 2.遍历 3.判断前一项和后一项是不是一样，一样的话删掉后一个

var arr = [ 1, 1, 1, 1, 1, 1, 4, 2, 3, 2, 1, 2, 3, 4, 2, 1, 2, 3, 4 ]
arr.sort()  //排序
for (var i = 0; i< arr.length;i++) {
    if (arr[i] === arr[i+1]) {  //前一项和后一项对比
        arr.splice(i,1)
        i--
    }
}

方案三：1.准备一个新数组 2.把原始数组内每一项依次插入新数组中，判断，新数组中没有，才插入

var newarr = []
for ( var i = 0; i < arr.length; i++) {
    if (newarr.indexOf(arr[i]) === -1) {
        newarr.push(arr[i])
    }
}

方案四：1.创建一个对象 2.遍历原始数组，把每一个数据当成 obj 内的键名来使用 3.把原始数组清空 4.遍历 obj，把每一个键名依次插入 arr 内

var obj = {}
for (i = 0;i<arr.length;i++) {
    var item = arr[i]  //把item 当作 obj 内的键名来使用
    obj[item] = 'a'
}
arr.length = 0  //把原始数组清空
for (var k in obj) {
    arr.push(k - 0)
}

方案五:1.利用 Set 数据结构 2.把Set 数据结果还原成一个数组

//var s = new Set (arr)
//方法一---Array.from()
//var r1 = Array.from(s)
//方法二---(...)
//var r2 = [...s]
var r1 = Array.from( new Set(arr))
var r2 = [...new Set (arr)]

作业

/**
*  1. 给出一个数组, 将数组内 所有的值 放大 100 倍
* 
*      原数组: [1, 2, 3, 4, 5]
*      处理后: [100, 200, 300, 400, 500]
* 
*  2. 给一个数组, 然后给一个新值, 将新值 插入数组后 排序(按照从大到小)
*      
*      原数组: [ 4, 5, 7, 9, 10, 2 ]
*      新值: 3
*      处理后: [10, 9, 7, 5, 4, 3, 2]
*/

简单理解JavaScript对象和数组

01-对象(Object)----复杂数据类型----可以看作一个‘盒子’，里面存放 无序 的数据

一、对象的创建

二、对象数据类型的基本操作(增删改查)

点语法：

数组关联语法(中括号语法)：

两个语法的区别：

三、对象的遍历 (for in 循环)

关键字 in

02-数组数据类型--Array---一般存储用以数据类型

一、如何创建数组？

二、数组内数据的排序

三、数组的基本操作

length属性：

索引属性

四、数组的遍历

五、数组练习

六、排序算法--冒泡

七、选择排序

数组常用方法Ⅰ

push()

pop()

unshift()

shift()

数组常用方法Ⅱ

reverse()

sort()

splice()

slice()

数组常用方法Ⅲ

concat()

join()

indexOf()

lastIndexOf()

数组常用方法Ⅳ---数组的遍历

forEach()

map()

filter()

find()

findIndex()

every()

some()

reduce()

八、数组塌陷

九、数组去重

作业

01-对象(Object)----复杂数据类型----可以看作一个‘盒子’，里面存放无序的数据