JavaScript数组

 数组

       1.基本数据类型变量都储存在栈区域 string number boolean undefined null

       2.引用变量储存在栈区域

       3.复杂数据类型储存在堆区域，赋值时是将对象在堆区域地址赋给变量

       对象内存结构

       //字面量方式创建对象obj

       var obj={

        name:'jack',

        age=18

       }

       var obj1=obj

       obj1.age=20

       console.log('obj.age:',obj.age)

    数组的常用方法

    object对象

    数组对象

        属性 和 方法

        var arr=[10,20,30]

        arr.length  属性

        方法  

        1.push

          => arr.push()//push方法  

          => 向数组追加元素

        2.pop

          => arr.pop()//pop方法

          => 弹出(删除)数组最后一个元素

        3.unshift

          => arr.unshift()//unshift 方法

          => 数组前面添加元素

        4.shift

          => arr.shift

          => 删除数组最前面元素

        5.splice//截取元素

          => arr.splice(下标，元素个数)

          => 删除下标开始n个元素，也可用其他元素来代替

          arr.splice(1,2,'截取后替代元素')

        6.reverse 反转数组

          => arr.reverse()//数组反转

        7.sort//数组排序

          => 默认从低到高，规则先转字符串，使用字符编码unicode

        8.concat

          => 多个数组进行并接

        9.join

          => 把数组里面的每一项内容连接起来，变成字符串

        10.slice

          => 获取到从下标开始后的数据

        11.indexOf

          => 找到数组中某一项的索引，也可以判断元素是否存在（-1）

        12.includes

          => 检测数组是否包含runnob（判断数组元素是否存在）

        ESS常用数组遍历

        1.foreach()

          => arr.foreach(function(index,item){

            //匿名函数  function(){}

            //index 第一个形参数组元素

            //item 第二个形参索引号（下标）

            console.log('index:',index,'item:',item)

          })

        //练习最高分最大值查找

        var max=0

        var arr=[98,67,78,89,95]

        arr.foreach(function(item,index){

            if(item>max){

                max=item

            }

        })

        console.log('最大值是：',max)

        2.map

          => 1.遍历数组，与foreach类似

             2.映射新数组，return返回值

          var arr=[1,2,3]

          var newArr=arr.map(function(item,index){

            //return 新元素

            return item+10

          })

          console.log(newArr)

        3.filter

          =>

          查找大于70分的成绩

          function testFilter(){

            var newArr=arr.filter(function(item){

                return item>70

            })

            console.log(newArr)

          }

          testFilter()

        4.find

          => 查找第一个满足的元素

        function testFind(){

            var newItem=arr.find(function(item){

                return item>80

            })

            console.log(newItem)

        }

        testFind()

        5.every

        => 遍历数组，查找数组元素是否全部满足条件

        //判断所有学生是否都及格

        function testEvery(){

          var isOk=arr.every(function(item){

            return item >60

          })

          console.log(isOk)

        }

        testEvery()

        6.some

          => 遍历数组，查找数组元素是否有满足条件，有一个满足条件就返回true

          判断成绩数组是否有不及格学生

        function testSome(){

            var isOk=arr.some(function(item){

                return item<60

            })

            console.log(isOk)

        }

        testSome()

        7.reduce

          => 1.遍历数组元素

             2.执行函数调用，将callFun函数计算结果

             var arr=[98,57,78,95,89,99]

             arr.reduce(function(previousValue，currentValue，currentIndex，arr){

                //previousValue 上一个值，如果initValue存在，第一遍遍历时previousValue就是initValue

                //currentvalue 当前元素组

                //currentIndex 当前数组下标

                // arr 函数组

                return previousValue

                console.log(previousValue,currentValue,currentIndex,arr)

            }，0)

            function test2(){

                arr.reduce(function(previousValue，currentValue，currentIndex，arr){

                //previousValue 上一个值，如果initValue存在，第一遍遍历时previousValue就是initValue

                //currentvalue 当前元素组

                //currentIndex 当前数组下标

                // arr 函数组

                console.log(previousValue,currentValue,currentIndex,arr)

                return previousValue    

            })

            }

            test2()

            //应用累加求和

            function test3(){

                var sum=arr.reduce(function(previousValue,currentValue){

                    return previousValue+currentValue

                },0)

                console.log(sum)

            }test3()

        数组的排序

        冒泡排序

          相邻两个数，两两比较，如果前面数大于后面数两两交换位置

          第一轮比较完，最大数到最后面

          第二轮重复上述操作，找到第二大数、

          3 4    3

          4 5    4

          n n-1  比较次数

          5  1   4

             2   3

             3   2

             4   1

        var arr=[89,98,78,68,76]

        for(var j=0;j<arr.length-1;j++){

            for(var i=0;i<arr.length-j-1;i++){ //相邻两个数比较 if(arr[i]>arr[i+1]){

                if(arr[i]>arr[i+1]){

                var temp=arr[i]

                arr[i]=arr[i+1]

                arr[i+1]=temp

                }

                }

        console.log(arr)

        }

        console.log('排序后：',arr)

 <!--

    选择排序

    排序思想

        1.n 个数  进行 n-1次选择

        2. 每次选择

               未排序数中找最小数下标，与前面的数交换位置

               例子下方test1

    数组去重

    例如[9,2,5,2,8,2,5] ->[9,2,5,8]

    方法一：利用indexOf 或 includes 实现

      思路：

      定义一个空数组 [] 储存去重后元素

      遍历原数组

        判断新数组中是否有原数组当前元素，如果没有，储存到新数组中

    方法二：利用双重for循环+splice实现

      外层循环遍历数组所有元素

         内层循环依次判断后面元素是否与外层循环元素相同，如果相同，截取掉

    代码下方test2

    -->

    <script>

        function test1(){

            var arr=[89,98,78,68,76]

            var n=arr.length

            // var minIndex=0 //假设最小数下标是第一个数

            for(var i=0;i<n-1;i++){//外层循环进行n-1次选择

                minIndex=i   //找最小数下标

                for(var j=1+i;j<n;j++){

                     if(arr[j]<arr[minIndex]){

                   minIndex=j

                    }

                    }

                    //交换位置

                     var temp=arr[i]

                     arr[i]=arr[minIndex]

                     arr[minIndex]=temp

                     console.log('第'+(i+1)+'次选择'+arr)

                    }

                    console.log(arr)

            }

        //test1()

        function test2(){

            var arr=[9,2,5,2,8,2,5]

            //方法一

          /*   var newArr=[]//储存去重后元素

            for(var i=0;i<arr.length;i++){//遍历原数组

                if(newArr.indexOf(arr[i])==-1){//判断新数组中是否有原数组当前元素，如果没有，储存到新数组中

                    newArr.push(arr[i])

                }

                // if(newArr.includes(arr[i])==false){

                // if(!newArr.includes(arr[i])){

                  // newArr.push(arr[i])

                // }

            }

            console.log(newArr) */

            /* var arr=[9,2,5,2,8,2,5]

            var newArr1=[]

            arr.forEach(function(item){

                if(newArr1.indexOf(item)==-1){

                     newArr1.push(item)

                }

            })

            console.log(newArr1) */

            //方法二

            for(var i=0;i<arr.length;i++){

                for(var j=i+1;j<arr.length;j++){

                    if(arr[i]==arr[j]){

                        arr.splice(j,1)

                        j--

                    }

                }

            }

            console.log(arr)

        }

        test2()