JS数组（Array）操作汇总

1、去掉重复的数组元素。
2、获取一个数组中的重复项。
3、求一个字符串的字节长度,一个英文字符占用一个字节,一个中文字符占用两个字节。
4、判断一个字符串中出现次数最多的字符，统计这个次数。
5、数组排序。

6、快排。

7、删除/添加数组项。

8、数组随机顺序输出。

9、数组求和、最大值。

10、判断是否为数组。

11、有一个int型数组，里面有若干数字。要求统计出一共有多少种不同的数字？每种数字出现的频率从少到多排列，频率相同则从小到大排列。

12、冒泡排序。

1、去掉重复的数组元素。

Array.prototype.unique = function() {
    var ret = [];
    var o = {};
    for(var i=0, len=this.length; i<len; ++i){
        if(!o[this[i]]){
            ret.push(this[i]);
            o[this[i]] = this[i];
        }
      }
    return ret;
}

var arr = [1,2,3,1,1,3,3,4,5,6,5,5,5,5,7,8,9,10,9,9,9];
var unique = arr.unique();

console.log(unique); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2、获取一个数组中的重复项。

 var arr = [1,2,3,1,1,3,3,4,5,6,5,5,5,5,7,8,9,10,9,9,9];
 Array.prototype.delete = function() {
 var arr = this;
 var obj = {};
 var delArr = [];
     for (var i = 0, l=arr.length; i < l;)
    {
         var key = arr[i];
         if (typeof obj[key] == 'undefined')
         {
             obj[key] = "1";
             i++;
             continue;
          }
         delArr.push(arr.splice(i, 1)[0]);
         var l = arr.length;
       }
       return delArr;
 }
 var delArr = arr.delete();//[1, 1, 3, 3, 5, 5, 5, 5, 9, 9, 9]

3、求一个字符串的字节长度,一个英文字符占用一个字节,一个中文字符占用两个字节。

 (function getByte(str) {
     var num = 0;
     for (var i = 0, l = str.length; i < l; i++) {
         if (str.charCodeAt(i) > 255) {
             num += 2;
         } else {
             num++;
         }
 }
      alert(num);
  })("你好，John!");

4、判断一个字符串中出现次数最多的字符，统计这个次数。

 //将字符串的字符保存在一个hash table中，key是字符，value是这个字符出现的次数
 var str = "abcdefgaddda";
 var obj = {};
 for (var i = 0, l = str.length; i < l; i++) {
     var key = str[i];
     if (typeof obj[key] == 'undefined') {
         obj[key] = 1;
     } else {
         obj[key]++;
10     }
 }
 /*遍历这个hash table，获取value最大的key和value*/
 var max = -1;
 var max_key = "";
 var key;
 for (key in obj) {
     if (max < obj[key]) {
         max = obj[key];
         max_key = key;
     }
 }
 alert("max:"+max+" max_key:"+max_key);

5、数组排序。

 function sortNumber(a, b)
 {
     return a - b
 }

 var arr = new Array(6)
 arr[0] = "10"
 arr[1] = "5"
 arr[2] = "40"
 arr[3] = "25"
 arr[4] = "1000"
 arr[5] = "1"

 document.write(arr + "<br />")
 document.write(arr.sort(sortNumber))

6、快排。

 //复杂度O(nlog2n) 最差O(n^2)

 function quickSort(arr){

         //如果数组只有一个数，就直接返回；
         if(arr.length<=1){
             return arr;
         }

         //找到中间的那个数的索引值；如果是浮点数，就向下取整
         var centerIndex = Math.floor(arr.length/2);

         //根据这个中间的数的索引值，找到这个数的值；
         var centerNum = arr.splice(centerIndex,1);

         //存放左边的数
         var arrLeft = [];
         //存放右边的数
         var arrRight = [];

         for(i=0;i<arr.length;i++){
             if(arr[i]<centerNum){
                 arrLeft.push(arr[i])
             }else if(arr[i]>centerNum){
                 arrRight.push(arr[i])
             }
         }
         return quickSort(arrLeft).concat(centerNum,quickSort(arrRight));

     };
     var arrSort = [33,18,2,40,16,63,27];
     var arr1 = quickSort(arrSort);
     console.log(arr1);

7、删除/添加数组项。

     1)删除第一项， shift()方法，返回该项

2)添加第一项, unshift()方法，返回该项

3)删除最后一项, pop()方法，返回该项

4)添加最后一项, push()方法，返回该项

5)slice(a,b)，a、b是返回项的起止项，不影响原数组

6)splice()：两个参数时，表示删除，参数意思为删除的第一项位置和要删除的个数，返回删除项；

三个参数，中间参数（删除项数）为0时，表示插入，第一个参数时插入位置，第三个是插入项数，返回空数组；

三个参数，起始位置、要删除的项数、要插入的项，表示替换，返回删除项

均影响原数组

8、数组随机顺序输出。

 function fnLuanXu(num) {
         var aLuanXu=[];
         for (var i = 0; i < num; i++) {
             aLuanXu[i] = i;
         }
         aLuanXu.sort(function(){return Math.random()>0.5?-1:1;})
         return aLuanXu;
     } 

9、数组求和、最大值。

 //求和
 Array.prototype.sum = function ()
 {
     for (var sum = i = 0; i < this.length; i++)sum += parseInt(this[i]);
     return sum
 };
 //求最大值
 Array.prototype.maxima = function ()
 {
     for (var i = 0, maxValue = Number.MIN_VALUE; i < this.length; i++)parseInt(this[i]) > maxValue && (maxValue = this[i]);
     return maxValue
 };
 //应用
 var arr = [1,21,3,4,22,45,6,7,32];
 alert(arr.join("+") + "=" + arr.sum()); //和：141
 alert(arr.join("|") + "中, 最大的数是:" + arr.maxima()); //最大数：45

10、判断是否为数组。

 //《javascript语言精粹》中答案
 var is_array=function(value) {
         return value && typeof value==='object' &&
             value.constructor===Array &&
             typeof value.length==='number' &&
             typeof value.splice==='function' &&
             !(value.propertyIsEnumerable('length'));
     }

 //方法1
 arr instanceof Array
 //方法2
 function isArray(o) {   return Object.prototype.toString.call(o) === '[object Array]';  }
 //方法3
 arr.constructor === Array && typeof arr === "object"

 //通用判断类型函数
 function is(type, obj) {
     var clas = Object.prototype.toString.call(obj).slice(8, -1);
     return obj !== undefined && obj !== null && clas === type;
 }

 JavaScript 类型表格

 Value                     Class      Type
 -------------------------------------
 "foo"                      String     string
 new String("foo")          String     object
 1.2                        Number     number
 new Number(1.2)            Number     object
 true                       Boolean    boolean
 new Boolean(true)          Boolean    object
 new Date()                 Date       object
 new Error()                Error      object
 [1,2,3]                    Array      object
 new Array(1, 2, 3)         Array      object
 new Function("")           Function   function
 /abc/g                     RegExp     object (function in Nitro/V8)
 new RegExp("meow")         RegExp     object (function in Nitro/V8)
 {}                         Object     object
 new Object()               Object     object

上面表格中，Type 一列表示 typeof 操作符的运算结果。可以看到，这个值在大多数情况下都返回 "object"。

    Class 一列表示对象的内部属性 [[Class]] 的值。

    JavaScript 标准文档中定义:[[Class]] 的值只可能是下面字符串中的一个：Arguments, Array,Boolean, Date, Error,Function,JSON, Math,Number, Object, RegExp,String.

11、有一个int型数组，里面有若干数字。要求统计出一共有多少种不同的数字？每种数字出现的频率从少到多排列，频率相同则从小到大排列

 var arr = [31,31,32,13,42,5,42,8,9,6,7,7,3,4,51,8,9,0,2,4,6];
 newArr(arr);
 function newArr(arr){
    arr.sort(function(a,b){return (a-b)});

    var len=arr.length;
    var newarr=new Array();
    var n=1;

    for(var i=0;i<len;i++){
     if(arr[i]==arr[i+1]){
         n++;
     }else{
         var newelement=arr[i]+"+"+n;
         newarr.push(newelement);
         n=1;
     }
     }
     console.log(newarr);

    var compare=function(x,y){
     var lab1=x.indexOf("+");
     var xvalue=parseInt(x.substring(0,lab1));
     var xlen=parseInt(x.substring(lab1+1));
     var lab2=y.indexOf("+");
     var yvalue=parseInt(y.substring(0,lab2));
     var ylen=parseInt(y.substring(lab2+1));
     if( (xlen>ylen) || (xlen == ylen && xvalue>yvalue)) return 1;
     if( (xlen<ylen) || (xlen == ylen && xvalue<yvalue )) return -1;
 }
    newarr.sort(compare);
    var ints=Array();
    for(var j in newarr){
     var lab3=newarr[j].indexOf("+");
     var intvalue=newarr[j].substring(0,lab3);
     ints.push(intvalue);
    }
    var types=newarr.length;/* types就是不同数字的个数 */
    console.log(types);
    console.log(ints);/* ints就是最后结果 */
 }

12、冒泡排序。

 var bubbleSort = function(array){
     var i = 0, len = array.length, j, d;
     for(; i<len-1; i++){
         for(j=0; j<len-i-1; j++){
             if(array[i] < array[j]){
                 d = array[j];
                 array[j] = array[i];
                 array[i] = d;
             }
         }
     }
     return array;
 };