JavaScript数组

什么是数组

数组可以把一组相关的数据一起存放，并提供方便的访问(获取）方式。.

数组是指一组数据的集合，其中的每个数据被称作元素，在数组中可以存放任意类型的元素。

数组 是一种将一组数据存储在单个变量名下的优雅方式。

使用构造函数创建数组对象

创建一个空数组

   var arr = new Array();

创建一个数组，里面存放三个字符串·

  var arr = new Array('张三', '李四', '王五')

创建一个数组里面存放4个数字

     var arr = new Array(1, 2, 3, 4)

使用字面量创建数组对象       

 var sum = 0;

        var arr = [1, 2, 3, 4]

        console.log(arr.length);

        // 获取数组中的元素：数组名[下标]

        console.log(arr[2]);

 打印出数组中所有元素.       

 //    方式一：

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

        // 方式二：for...in...

        for (var i in arr) {

            // console.log(arr[i]);

            if (arr[i] % 2 != 0) {

                console.log(i, arr[i]);

                sum += arr[i];

            }

        }

        console.log(sum);

数组中常用的函数     

  var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]

        // 向数组中添加元素

        // push:向数组的后面添加元素

        var result_1 = arr.push(10);

        // unshift:向数组的前面添加元素

        result_1 = arr.unshift(0);

        console.log(result_1, arr);



        // 删除数组中的元素:

        // pop():删除并返回数组中的最后一个元素

        var result_2 = arr.pop();

        // shift():删除并返回数组中的第一个元素

        result_2 = arr.shift();

        console.log(result_2, arr);

var arr = ['张三', '李四', '王五']

        // sort:进行升序，先将数据中的元素转化成字符串再进行升序

        var result_3 = arr.sort();

        console.log(result_3);

        // reverse():将字符串类型的数组进行降序排列:先试用sort()，

        // 然后再使用reverse()进行倒叙

        console.log(result_3.reverse());

        //join()： 将一个数组中的所有元素拼接成一个字符串，用逗号隔开

        console.log(arr.join(","));

        // concat():将某个元素添加到数组的尾部

        console.log(arr.concat("老六"));

splice()从指定位置删除指定长度的元素 

  // splice()从指定位置删除指定长度的元素

        var arr = [12, 15, 489, 5848, 484, 1,]

        console.log(arr.splice(2, 2, arr));

        // slice():复制从指定位置到结束位置的元素

        console.log(arr.slice(1, 4), arr);

        // indexOf():获取指定元素的索引

        console.log(arr.indexOf(1), arr);

定义一个数值比较函数 

 // 定义一个数值比较函数

        var arr = [12, 15, 489, 5848, 484, 1,]

        function comp(a, b) {

            return b - a;//如果是升序，则是a-b

        }

        // 利用比较函数实现数值的升序排列

        console.log(arr.sort(comp));

数组的去重问题
 

         //数组的去重问题

        var arr = [50, 60, 90, , 50, 80, 40, 90, 80, 40, 50]

        // 先定义一个空数组，用来存放不重复的元素

        var newArr = [];

        for (var i in arr) {

            //判断一下将要添加元素是否存在于新数组nweArr中，如果存在，不添加

            // 反之则添加

            if (newArr.indexOf(arr[i]) == -1) {

                // 将不重复的元素放到数组newArr中

                newArr.push(arr[i])

            }

        }

        console.log(newArr);

        // 下面这种方法去重方式会改变原数组

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

            var temp = arr[i]

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

                if (arr[j] == temp) {

                    arr.splice(j, 1)

                }

            }

            // console.log(arr);

        }

        console.log(arr);

   将数组中的元素反转，不使用reverse()函数

        // 将数组中的元素反转，不使用reverse()函数

        var arr = [10, 20, 30, 40, 50, 60]

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

            var temp = arr[i]//根他交换的是arr.length-i-1

            arr[i] = arr[arr.length - i - 1]

            arr[arr.length - i - 1] = temp

        }

        console.log(arr);

 清空数组的三种方式

        // 清空数组的三种方式

        arr = [];

        arr.length = 0;

        arr.splice(0,arr.length)

冒泡排序

     

   // 比较了几轮

        var arr = [10, 50, 30, 15, 80, 40]

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

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

                // 当前面的元素比后面的大时，俩着位置交换

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

                    var temp= arr[j]

                    arr[j]=arr[j+1]

                    arr[j+1]=temp

                }

            }

            // console.log(arr);

        }

        console.log(arr);