js 数组操作汇总

最新推荐文章于 2023-05-11 15:32:15 发布
最新推荐文章于 2023-05-11 15:32:15 发布
阅读量264 收藏
点赞数 1
文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_39427902/article/details/87450199
版权

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 &lt; l; i++) { 
     var key = str[i]; 
     if (typeof obj[key] == 'undefined') { 
         obj[key] = 1; 
     } else { 
         obj[key]++; 
    }
}
/*遍历这个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;
};
阿里笔试-数组操作-找出两个数组中不同的元素


 function diff(arr1,arr2){ 
  var ress = []; 
  var arr = arr1.concat(arr2); 
  for(var i=0,len=arr.length;i<len;i++){ 
     if((arr1.indexOf(arr[i])>=0 && arr2.indexOf(arr[i])<0) || (arr1.indexOf(arr[i])<0 && arr2.indexOf(arr[i])>=0)){ 
        ress.push(arr[i]); 
     } 
  } 
  return ress; 
} 
var arr1 = [1,2,3,5,7,6]; 
var arr2 = [1,2,5]; 
var res = diff(arr1,arr2); 
console.log(res);//[3, 7, 6] 
判断数值数组中各个数字出现的奇偶次数

 var arr=[3,1,2,2,1,3,1]; 
    var sum=[]; 
    var res=[]; 
    var count=0; 
    var temp; 
    for(var i=0;i<arr.length;i++){ 
      if(res.indexOf(arr[i])==-1){ 
        res.push(arr[i]); 
      } 
    } 
    for(var i=0;i<res.length;i++){ 
      for(var j=0;j<arr.length;j++){ 
        if(arr[j]==res[i]){ 
          count++; 
        } 
      } 
      sum.push(count); 
      count=0; 
    } 
    console.log(res);//[3,1,2] 
    for(var i=0;i<res.length;i++){ 
      var str=(sum[i]%2==0)?"偶数":"奇数"; 
      console.log(res[i]+"出现了"+sum[i]+"次"); 
      console.log(res[i]+"出现了"+str+"次"); 
    }

 

ES6 Array 操作方法

map 映射(一个对一个) 对于数组中的每一个项，都有一个返回值

 //对于每个item都有一个改变后的返回值
 
 let arr=[1,2,3,4];
 let result=arr.map(function(item){
     //item是数组中的每一项
     return item*2;
 });
 -> result=[1,4,9,16]


 let score=[19,58,80,97];
 let result=score.map(function(){
     return item>=60?'及格':'不及格';
 })
 -> result=[不及格，不及格，及格，及格];
reduce 汇总（一堆出来一个）计算总数，计算平均值 比较费劲

 //求和
 let arr=[11,122,333,344];
 let result=arr.reduce(function(tmp,item,index){
     return tmp+item;
 })
  • 过程是这样滴：假如我们要计算一个加法运算,11+122+333+344;第一步我们要计算11+122，得到一个中间结果133,然后用中间结果去加333，，然后又会得到一个中间结果466，然后用466去加344得到最终结果810
  • reduce的工作原理也是这样，首先因为刚开始没有中间结果，所以tmp被赋值为数组中的第一项 item是数组中第二项，index是1,然后计算11+122，把得到的结果133 return出去，第二次计算时tmp就是12+122的结果133，item是数组中的第三项333,index是2，把tmp+item的结果466返回出去；第三次计算时的tmp就是466,item是344，index是3,把结果返回出去，因为这是数组中最后一项，所以把结果返回给result.

       //计算平均数 最后一次要求平均数
        //求和
        let arr=[11,122,333,344];
        let result=arr.reduce(function(temp,item,index){
            if(index!=arr.length){//不是最后一次，求和
                return temp+item;
            }else{//最后一次
                return (temp+item)/arr.length;
            }
        })
* 应用：计算购物车的总价格
filter 过滤器（留一部分，消失一部分）

 //通过返回的是true还是false来决定是否返回出去
 //例子：返回能被3整除的数        
 let arr=[12,5,8,9];
 let result=arr.filter(function(item){
     if(item%3==0){
         return true;
     }else{
         return false;34567812
     }
     //简写  return item%3==0;
 })
forEach 和for循环一样滴，没有返回值，就是for循环换了种写的方式

 let arr=[12,12,33,45];
 arr.forEach(function(item,index){
     console.log(item);
     -> 12,12,33,45
 })

 

旧识君
关注
JavaScript常用数组方法-汇总
JackieDYH的博客
05-01 885
合并数组，可以合并一个或多个数组，会返回合并数组之后的数据，不会改变原来的数组；
js数组篇汇总
weixin_34320159的博客
03-20 146
前言 本文针对于自己的一个 js数组篇 课程总结 方法 1. 数组创建 1. var a = [3,5,7] // [3,5,7] 2. var a = new Array(3) // [ , , ] 3. var a = Array.of(3) // [3] 复制代码 Array.of()是es6的方式，为了解决上述构造器因参数个数不同，导致的行为有差异的问题 2. 判断数组中是否含有指定...
重磅！超详细的 JS 数组方法整理出来了
祈澈菇凉
01-06 1766
作者：Yushiahttps://juejin.cn/post/6907109642917117965数组是 js 中最常用到的数据集合，其内置的方法有很多，熟练掌握这些方法，可以有效的...
js数组常用方汇总
weixin_43172616的博客
11-21 132
数组
☆JS中数组常用的方法汇总
凯凯凯凯凯凯凯凯
10-23 199
js中数组的常用方法汇总
JavaScript数组操作函数汇总
12-12
JavaScript中的数组操作函数是编程中不可或缺的部分，它们提供了丰富的功能，使得处理数组数据变得更为便捷。以下是关于标题和描述中提到的一些常用数组操作函数的详细解释： 1. **push()**： - `push()` 函数允许...
JavaScript数组常用操作技巧汇总
12-09
这篇文章将汇总JavaScript数组的一些常用操作技巧，帮助开发者更好地理解和利用数组功能解决问题。 ### 一、数组的性质 在JavaScript中，数组本质上是特殊的对象，其属性是通过偏移量的索引来表示的。虽然我们可以...
js array数组对象操作方法汇总
10-17
本文将详细介绍JavaScript中数组对象的操作方法，包括数组的创建、遍历、合并、排序、截取、删除、反转以及转换为字符串等操作，帮助读者更深入地掌握数组的应用。 1. 创建数组 数组可以通过数组字面量或Array构造...
JS中数组的常用方法汇总
weixin_46045382的博客
08-31 569
JS中迭代数组数组元素的方法，forEach()按照遍历顺序使数组中的每个元素执行一遍自定义函数。filter()返回一个新数组，新数组中是通过函数检测的数组元素。map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。some() 方法用于检测数组中的元素是否满足指定条件（函数提供）。every() 方法用于检测数组中的元素是否满足指定条件（函数提供）。...
JavaScript数组方法汇总(史上最全)
liumuye88888的博客
11-02 539
一、在JavaScript中创建数组的方法 (1)、Array构造函数创建数组 在这里插入代码片
Javascript系列之—常见的Array对象汇总
zhou139856的博客
07-02 321
Javascript 常见的数组方法汇总整理
超详细的JavaScript Array数组相关汇总
苦逼的程序猿☺
11-29 2038
前言在RN中涉及到比较多的数组的相关操作，所以在这里对这块内容进行一个整理总结，也是对这块知识的学习！ 本文前一部分内容，根据菜鸟教程整理！创建数组创建数组一般来说有下边三种方式：var array = new Array(); var array = new Array(length); var array = new Array(element0, element1, ..., element
Javascript 数组方法整理汇总
m0_61168888的博客
04-11 229
数组提供了很多方法，为了让开发变得简单高效，在今天的文章中，我们整理汇总了一些有用的JavaScript数组方法。 1、Array.map() map() 方法返回一个新数组，数组中的元素为原始数组元素调用函数处理后的值。 map() 方法按照原始数组元素顺序依次处理元素。 注意，map() 不会对空数组进行检测，它也不会改变原始数组。 const list = [1, 2, 3, 4];list.map((el) => el * 2); // [2, 4, 6, 8] 2、Arra..
js数组操作方法总结
Jialins的专栏
07-04 216
1. consat():数组拼接的功能 ,返回新数组，原数组不受影响。 var arr1 = [1, 2, 3]; var arr2 = [4, 5, 6]; var result = arr1.concat(arr2); console.log(result);// [1,2,3,4,5,6] console.log(arr1);// [1, 2, 3] console.log(arr2);// [4, 5, 6] 2. join():将数组中所有元素都转化为字符串并连接在一起，返回新数组...
js数组方法归纳总结
weixin_41748671的博客
03-23 343
方法主要分为两类： 第一类：改变原数组 第二类：不改变原数组
js数组常用方法总结(三) push、concat
仰柔川
09-22 476
push() 在原数组的基础上修改的，执行push()方法后原数组的值也会变，在原数组后面添加值； 返回值：添加元素后的数组的长度 concat() 连接两个或多个数组，返回一个新数组 一个数组先把原数组的每个值复制到一个新/另的数组，然后在新/另数组上进行操作，不会改变原数组的值。 如果参数不是数组，不管参数个数有多少个，push()和concat()都会直接把参数添加到数组后；...
js实现数组去重的方式(7种)
热门推荐
qq_52732369的博客
12-11 7万+
js实现数组去重的7种方式
js数组(Array, arr)常用的方法
最新发布
都已经是第二年的立春、又何必执着于、当年的盛​夏呢？
05-11 2206
功能：向末尾添加- 是否接受参数：支持传入多位参数，传入一个就添加一个，传入多位就添加多位- 是否操作源数组：是- 返回：返回添加的数据。
js动态产生对象push进数组，发现数组所有元素（element or object）一样
码梦为生
10-19 6271
版权声明：需要转载的话，请先联系我哦！ https://blog.csdn.net/wwt20180911/article/details/83149436 原因：对象是同一个对象，动态创建对象时，不断对对象赋值，push进数组，数组[obj,obj,obj],所有的obj值相同，因而导致数组中都是同一个对象 talk is cheap,show you the code 错误写法： //处理...
JavaScript数组操作技巧汇总
"这篇文章总结了13个JavaScript数组操作的实用技巧，包括删除重复项、替换特定值、使用Array.from模拟.map效果、清空数组、数组转对象、填充数组、合并数组、求交集、删除虚值、随机取值、反转数组、lastIndexOf方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值