对象

用，隔开

最后结束的时候不用加，

{}里是数据———key：value（键值对）

联想截图_20231030221052.png

增删改查

增就是上面讲的添加键值对

删改查 联想截图_20231030223700.png 2. 用中括号

引号必须加，不然就是一个相对于全局的变量名了

遍历-对象

for in

不同数据类型的存储

问题一： 你想要单独改一个的值，所以这样写但是最后发现一个bug，虽然obj2如你所愿，单独改了一个值。但是obj也会被改，但是你并不想原来的改变

原因：因为两个变量访问的是一个地址，也就是说一个刷卡进房间后拿了一个东西，另一个人也刷卡进了同一个房间，所以房间不管怎样都是少了东西

问题二： 结果是false

...

重点： 分清楚哪个在栈里，哪个在堆里(简单类型，复杂类型)

如何做到真正复制，且不双方影响-对象

创建新的空对象，往空对象里加，空对象会是一个新地址，所以它改变的话，所以不会影响到之前的

如下图示例：

数组

数组[]里也可以再套{} 联想截图_20231031221546.png

联想截图_20231031221605.png .length（可读可写）可用于清空数组

索引 01234....console。log（arr[0]）即把数组里的第一个数据拿出来

遍历-数组

通过for循环把一个数组遍历

<而不是<=,因为你索引的时候是从0开始的

//遍历
        var arr3=[3,4,5,6,7,8]
        for(var i=0;i<arr3.length;i++){
            console.log(arr3[i])
        }

效果

联想截图_20231101134951.png

如何做到真正复制，且不双方影响-数组

//遍历
        var arr3=[3,4,5,6,7,8]
        for(var i=0;i<arr3.length;i++){
            console.log(arr3[i])
        }//这里的for循环是用来遍历用

        var arr4=[] //空数组
        for(var i=0;i<arr3.length;i++){
           arr4[i]=arr3[i]
        } //这里的for是赋值用
        console.log(arr4)
        //——————————成功复制出一份
        arr4[0]="aaaa"
        console.log(arr3,arr4)
        //______对某一元素进行改变（新开了一间房，arr3中数据不变，只改变arr4）

数组排序

1.冒泡排序

实现方式是把最大的沉下去

n个交换位置

1最基础的冒泡算法（2个）

空盒子法

  var arr=[4,3]
       
       var temp=arr[0]
       arr[0]=arr[1]
       arr[1]=temp
       console.log(arr)

2这种for循环也可以实现两数交换，不过这个已经被写死了，数据多了不推荐

 var arr=[4,3]
       for(var i = 0;i < arr.length;i++){
        if(arr[0] > arr[1]){
            var temp = arr[0]
            arr[0] = arr[1]
            arr[1] = temp
        }
       }
       console.log(arr)

第一轮

应该让0改为i，1改为i+1

其中的减1操作，是为了避免出现i++不存在的情况，那样就没有意义了

var arr=[4,3]
       for(var i = 0;i < arr.length-1;i++){
        if(arr[i] > arr[i+1]){
            var temp = arr[i]
            arr[i] = arr[i+1]
            arr[i+1] = temp
        }
       }
       console.log(arr)

但是这样只是一轮循环，只能把最大的数沉下去 接下来进行第二轮

而在第二轮第三轮第四轮的时候，我们可以把上面第一遍的for再复制下来

但是需要注意的是，这里我们建议，每多一轮，就在length后再多减一次。这样可以减少无用的对比，也就是前面循环已经排好的，我们并不需要再比一次

优化总结

在一个大for里套你的这个循环，把-1-1改成-m就可，可以避免你一次一次复制再-1的操作

这样更便捷

做两层for循环（外面-1，里面-1再-外面的这个索引值）

 var arr = [4, 3, 2, 1]
 for (var m = 0; m < arr.length - 1; m++) {

            for (var i = 0; i < arr.length - 1 - m; i++) {
                if (arr[i] > arr[i + 1]) {
                    var temp = arr[i]
                    arr[i] = arr[i + 1]
                    arr[i + 1] = temp
                }
            }

        }
        console.log(arr)

2.选择排序

实现方式是把最小的放前面联想截图_20231101161438.png

 var arr = [4, 3, 2, 1]
 for (var m = 0; m < arr.length - 1; m++) {

            var minIndex = m
            for (var i = m + 1; i < arr.length; i++) {
                if (arr[i] < arr[minIndex]) {
                    minIndex = i
                    var temp = arr[m]
                    arr[m] = arr[minIndex]
                    arr[minIndex] = temp
                }
            }

            // var temp = arr[m]
            // arr[m] = arr[minIndex]
            // arr[minIndex] = temp
        }
         console.log(arr)

交换的这个步骤，上面这两个地方都可以

如果它这个数第0项本来就是最小值，那么就相等，没有意义比那一次进行交换，所以优化为：加一个if判断 if (minIndex !== m)

var arr = [4, 3, 2, 1]
        for (var m = 0; m < arr.length - 1; m++) {

            var minIndex = m
            for (var i = m + 1; i < arr.length; i++) {
                if (arr[i] < arr[minIndex]) {
                    minIndex = i
                }
            }
            if (minIndex !== m) {
                var temp = arr[m]
                arr[m] = arr[minIndex]
                arr[minIndex] = temp
            }

        }
        console.log(arr)

数组的常用方法

会对原数组造成影响的

push

push： 后面追加元素

push的返回值： 数组追加完之后的长度，也就是返回的是长度

tip： 还可以用做将遍历的收集在一个数组里

pop: 后面删除元素

pop的返回值： 返回的是后面追加的这个元素

联想截图_20231101170218.png

unshift: 前面追加元素

unshift的返回值： 长度

shift： 前面删除元素

shift的返回值： 返回的是前面加的的这个元素

splice可用于中间追加或删除（前后也行，但是麻烦不用），既可以增加也可以删除

删除

splice（1，1）第一个是索引，第二个是步长（也就是从这个索引开始往后删几个）增加直接在索引，步长后加你需要的东西如果不想删了再加，那就把步长改为0，即可只加

注意：是指在1的这个地方不删，然后加在1前面

resver: 倒序

sort（自动化排序）： 默认按照位数排序，拆解字符

如果想实现正常的大小排序，需要用回调函数

a-b就是从小到大，b-a就是从大到小（a，b为行参）

不会对原数组造成影响的

concat： 拼接

其返回值： 就是结果

联想截图_20231101174603.png 拼接后，可以直接在后面加数（参数可以传多个）

如何做到真正复制，且不双方影响-concat

联想截图_20231101175318.png

join: 数组转成字符串

如果不加.join的话，打到屏幕上效果为数组强转为字符串并且默认用，隔开

加.join的话联想截图_20231101175730.png 效果：联想截图_20231101175741.png .... 在页面写li 联想截图_20231101180301.png 效果联想截图_20231101180247.png 但是问题是，此时页面中li之间会用，隔开

所以此时就需要运用到我们的join方法了。方法同上

slice(splice会对原数组增减，这个不会)：截取字符串，不影响原数组

1. 传两个参数的话，包前不包后（开始和结束索引处）

联想截图_20231101181508.png 也就是最后会截取出“aaa”和“bbb”

2. 传一个参数的话（从当前所传的索引到后面全部）

3. 不传参数（相当于又复制了一遍）

如何做到真正复制，且不双方影响-slice ↑↑↑ 3.不传参

4.还可以传负数（负数的含义就是，倒着数，第一个是-1）

indexOf： （从前面开始）返回我们所要查找的内容的索引值

联想截图_20231101183138.png 如果遇到重名的，只会返回来查到的第一个

如果就是想查后面的，就改变索引开始的地方联想截图_20231101183301.png

lastIndexOf： （从后面开始）返回我们所要查找的内容的索引值

数组去重

方法111

再弄一个空数组，把原来的数放进去，然后在这个数组中做一个if条件判断，我们查一下即将要装的这个数组是否已经在这里面了，如果在就不装了（即实现对其的一个筛选去重）

1.首先

复制

2.去重（index可以帮助查找） 方法222（利用对象：对key重复赋值，会被覆盖）

把arr中的每个内容当作一个key值

优点：适用面广，{“”}可以加各种类型参数

联想截图_20231101185638.png ...

联想截图_20231101190257.png

红线下第二部分指的是，只打印变成key值的i。即可把赋的值“随便”去掉联想截图_20231101190234.png 不过key被做成字符串了，此时只需将push（i）变成push（Number（i））或者parseint（i）又或者直接（i-0）。这样就可以转成数字

方法333new Set（不允许有重复的）

转换成set结构

还需要再转回数组（用Array.from）

方法444： splice直接删去

数组常用方法（续）

都用到了回调函数

遍历—foreach

foreach： 遍历

（用到了回调函数，会被foreach自动调用，所以不需要你主动去调用）

联想截图_20231101192409.png

联想截图_20231101192358.png

map: 映射

原来里面的数会被function映射成返回值。所以把你的需求写在返回值return里就行

比如我想让数组里的值平方联想截图_20231101193143.png 当然也可以用for循环

模糊查询fliter数组

filter: 过滤（模糊查询）

返回值有true（满足条件）和flase（不满足）又或者直接写需满足的条件

联想截图_20231101194614.png 所以结果就是300，其他被过滤掉了 eg.案例（数组里面套对象）

联想截图_20231101203857.png

every: 需要每一个都满足，不然就是flase

联想截图_20231101205553.png

some: 只要一个满足就是true

find: 找到满足条件的东西（跟过滤属性有点像）

（不过如果符合条件的有重的，只能找到一项）

联想截图_20231101210939.png

reduce: 叠加（累乘...也可以实现）

基于初始值实现

function回调函数+初始值（一般是0）

联想截图_20231101211438.png

JS学习之—对象与数组（43~54）

对象