Javascript系列（第四节.数组）

数组的两种:改变原数组不改变原数组.
数组:数据的集合
数组定义:

字面量方式定义数组: 　　

　　var arr=[ ];定义了一个空数组;
　　var arr=[1,2,3,4,5,6];定义了一个六位具体元素的数组]
构造函数方式定义数组:
　　var arr=new Array[ ];定义了一个空数组;
　　var arr=[3]; 定义了一个数组,有一个元素.
　　var arr=(5); 一个数字为参数,表示创建了一个5个空元素的数组
　　var arr=("5"); 一个字符串数字的参数,表示创建了一个元素为"5"的数组.
　　var arr=new Array(4); 定义了一个内容长度为4的数组.
获取数组长度的属性: length
对象名.属性名

数组元素的基本操作
数组下标:从0开始计算.
基本数组元素的增删改查
数组遍历
案例:存入1--100;

var arr=[ ];
for (var i-0;i<=100;i++){
arr[i] = i ;
}

for in 遍历数组(for..in 只能遍历对象,数组也是对象)
特点: 没有循环条件, 自动取出下标 ,下标类型为string

for(var key in obj ){ 
console.log(key,obj[key]);
}
for(var index in arry){
console.log(index,arry[index]);
}

　二维数组

定义二维数组:元素以一维数组的方式存在.
var arr=[ [ ],[ ] ];

二维数组的遍历:

  for(var i=0;i<arr.length;i++){
     for(var j=0;j<arr[i].length;j++){
          console.log(arr [i] [j]);
            }
     }

数组方法;

改变原数组的方法：

　push（）：向数组的尾部添加一个或者多个元素用法：arr.push（）返回新数组的长度，原数组改变。

pop（）：删除数组尾部的数据，一次删一个用法：arr.pop（）返回删除的元素，原数组改变。

　unshift（）：向数组的头部添加一个或者多个元素用法：arr.unshift（）放回新数组，原数组改变。

　shift（）：删除数组的第一个元素，返回新数组，原数组改变。

　splice（）：

　　　　arr.splice（start ，length ）删除从开始位置指定length个元素，返回删除的元素，如果不加length 删除start位子及后面所有元素，原数组改变。

　　　　arr.splice（start ，length ，num参数）如果length是0，在start位置处添加num数据，删除0个元素，返回空值，原数组改变。

　　　　arr.splice（start ,length ,num参数）如果length是大于0，在start位置开始删除length个数据，再添加num数据，返回删除的元素，原数组改变。

　　　　arr.reverse（）将数组倒叙，排列返回排列后的新数组。

　　不改变原数组的方法

　arr.slice（start ，length） 1.截取从start位置到length位置的元素返回截取元素组成的新数组。

　　　　　　　　　　　　　2.如果参数只有start，截取从start位置到数组最后返回截取元素组成的数组。

　arr.join（“ - ”）使用“ - ”将数组元素连接起来返回一个字符串。

　arr.concat（barr， arr）将一个或者多个数组所有元素拼接在arr后面，返回拼接后的数组。

堆和栈

栈当定义一个变量的时候,计算机在内存中开辟一块存储空间存放这个变量,这个空间称为栈.
特点：先进后出.后进先出,
存放的是基本类型的数据
如果变量是引用类型，栈中存入的是引用数据类型的地址
所有浏览器都有垃圾回收机制。
堆堆中存入很多数据，一般存放的是对象引用数据类型
按值传递和按引用类型的区别
按值传递值改变互不影响
引用传递一个变大家都变

冒泡排序：

  function fnSort(arr){
        var t=0;
        for(var i=0;i<arr.length;i++){
            for(var j=0;j<arr.length-1-i;j++){
                if(arr[j]>arr[j+1]){
                        t=arr[j];
                        arr[j]=arr[j+1];
                        arr[j+1]=t;
                        }
                   }
              }
           return  arr;
       }
       var brr=[34,2,56,78,54,90];
       fnSort(brr);
       alert(brr);    // [2,34,54,56,78,90]

选择排序;

###### 一：
   function fnSort(arr){
            var t=0;
            for(var i=0;i<arr.length-1;i++){
                for(var j=i+1;j<=arr.length-1;j++){
                     if(arr[i]>arr[j]){
                        t=arr[i];
                        arr[i]=arr[j];
                        arr[j]=t;
                    }
                }
          }
          return arr;
     }
     alert(fnSort([23,1,45,76] )  );   //[1,23,45,76]
    
######  二：  
   function xzFn(arr){
                var temp=0;
              for(var i=0;i<arr.length-1;i++){
                    var index=i;
                   for(var j=i+1;j<arr.length;j++){
                      if(arr[index]>arr[j]){
                             index=j;
                              }
                        }
                        if(index!=i){
                            temp=arr[i];
                            arr[i]=arr[index];
                             arr[index]=temp;
                        }
                  }return arr;
            }
  
        alert(fnSort([23,1,45,76] )  );  //[1,23,45,76]

数组去重：

var arr=[56,67,34,7,4,64,6,54,3,4,5,3,6]
alert(noRepeat(arr));
  function noRepeat(arr){
        var  new Arr=[ ];
        for (var i=0; i<arr.length;i++){
            if(!hasEleInArr(newArr,arr[i])){
            //.判断原数组中的每一个元素在新数组中是否存在
            //如果不存在，把这个元素添加到新数组中
              newArr.push(arr[i]);
                }
            }
       return  newArr;
       }
       

   function hasEleInArr(arr,ele){          //判断 一个元素在数组中是否存在
         for(var i=0;i<arr.length;i++){
               if(arr[i]==ele){
               return true ;     //表示存在
                }
           }
           return false;      //表示不存在
           }

var arr=[1,1,1,25,5,5,6,6,]
alert(noRepeat(arr));
  function noRepeat(arr){
  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--;
                }
           }
      }
  return arr;
  }

　　Sort排序方法

　　sort( ) 默认按照字符排序,如果数组元素为数字,会自动把数字转换为字符

　　sort( ) 方法进行数值排序,需要设置一个参数,这个参数是一个函数,函数返回正数,升序,返回负数,降序

var arr=[23,8,6,7,199]
arr.sort(function(){
    return Math.random()-0.5;
})
    alert(arr);

ES5数组方法：

arr.forEach(function(ele,index,arry) { } );本质上是for循环,元素,下标,本身,遍历数组，没有返回值。

arr.indexOf（）判断一个数在数组中是否存在，如果存在，返回这个数在数组的下标，如果不存在就返回 -1 。

arr.map（）遍历数组。

arr.indexof(ele) 从前往后找

arr.indexof(ele,index);

arr.lastIndexof(ele); 从后往前找

arr.lastIndexof(ele,index);

var newArr= arr.filer(finction(ele,index,arry){ return true/false ;根据里边条件真假的布尔值进行过滤 } );过滤

varnewArr=arr.map(function(ele,index,arry){return 处理的结果;}); 映射为新的数组

arr.reduce(function(prev){return prev结果作为新数组进入函数继续执行;})

var result=arr.reduce(function(prev,next,index,arry({return prev ;}) result可能为数组,字符串,数字

var newArr=arr.reduce(function){prev,next,index,arry){ return prev; },[]) 结果新数组,

var obj=arr.ruduce(function(prev,next,index,arry){return prev; },{}); 结果为新对象;