数据存储类型之间的区别

引入‘堆’和‘栈’

• 我们的存储空间分为‘堆’和‘栈’两种

• 堆：用于存放基本数据类型的内容
• 栈：用于存放复杂数据类型的内容

两种数据类型之间的比较

• 基本数据类型之间是值的比较
• 复杂数据类型之间是地址的比较

函数参数传递

基本数据类型和复杂数据类型的区别

1. 因为复杂数据类型变量存储的是地址，真实内容在堆里
2. 所以当obj2=obj1时，是将obj1的地址赋给obj2,他们指向同一个内存空间
3. 所以当obj2的内容改变时，obj1的指向的内存空间也会改变

数组的基本方法

        //push:在数组的最末尾增加一个元素
         arr.push(6)
         console.log('push:',arr)
        // pop:在数组的最后面删除一个元素
        arr.pop()
        console.log('pop:',arr)
        // unshift:在数组的最前面增加一个元素
        arr.unshift(0)
        console.log('unshift:',arr)
        // shift:在数组的最前面删除一个元素
        arr.shift()
        console.log('shift:',arr)
        // splice:从哪个索引位置开始截取，截取几个元素，替换的新内容
        arr.splice(1,2)          //替换的新内容可以不写，从1号位置截取，截取两个内容
        console.log('splice从1号位置截取，截取两个内容:',arr)
        arr.push(2,3)
        console.log('push两个参数：',arr)
        arr.splice(1,2,'我是新内容')
        console.log('splice增加新内容：',arr)
        // reverse:调换数组位置
        arr.reverse()
        console.log('reverse:',arr)
        // sort:默认排序，按照字符编码Unicode
        arr.splice(2,1,8)
        console.log(arr)
        arr.sort()
        console.log(arr)
        //sort按字典顺序排序
        var arr2=[23,45,77,23,58,12,7]
        arr2.sort(function(a,b){
            return (a-b)
        })
        var fun = function(a,b){
            if(a<b){
                return -1
            }
        }
        arr2.sort(fun)
        console.log(arr2)
        //简写
        arr2.sort(function(a,b){
            return(a-b)
        })
        // concat:数组拼接
        var arr3=arr2.concat(2,2,2)
        console.log('数组拼接：',arr3)
        // join: 把数组每一项连接起来，变成一个字符串
        var arr4=arr3.join('-')
        console.log('join-连接输出：',arr4);
        //indexof:用来找某个元素的索引，没有就会返回-1
        if(arr3.indexOf(23)==-1){
            console.log('没有这个数')
        }else{
            console.log('索引为',arr3.indexOf(23))
        }
        //includes:判断数组中是否有某个元素，有就返回true,没有就为false
        console.log(arr3.includes(45))
        console.log(arr3.includes(4))

slice()方法

数组遍历

 var arr = [98,78,86,59,94]
        arr.push(100)

        
        //forEach:遍历数组，用于输出数组
        function testForeach(){
            arr.forEach(function(item,index){
                console.log(item,index)
            })
        }
        testForeach()

        //map:遍历数组，返回一个新数组，return对原数组每一项进行操作
        var newarr=arr.map(function(item,index){
            return item+2
        })
        console.log(newarr)
        
        //filter，遍历数组，返回满足条件的元素形成一个新数组
        var newarr2=arr.filter(function(item){
            return item>90
        })
        console.log(newarr2)
        //find:遍历返回满足条件的第一个元素
        var newItem=arr.find(function(item){
            return item<80
        })
        console.log(newItem)
        //every:全都满足为ture,有一个不满足返回为false
        function testEvery(){
            var isOk=arr.every(function(item){
                return item>60
            })
            console.log('isok:',isOk)
        }
        testEvery()
        //some 只要有一个不满足为ture
        function testsome(){
            var isOk=arr.some(function(item){
                return item<60
            })
            console.log('isok:',isOk)
        }
        testsome()
        //reduce 累加求和，reduce() 方法接收一个方法作为累加器，数组中的每个值(从左至右) 开始合并，最终为一个值。