js中，数组对象操作——双层遍历-for循环之splice-删除、push-添加 & 数组中添加对象 & 删除数组中对象 & 数组中对象的参数值置空

于 2024-03-27 09:26:30 发布
阅读量755 收藏 8
点赞数 6
分类专栏： js知识 文章标签： javascript 开发语言 ecmascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44867717/article/details/137065533
版权
文章详细描述了在JavaScript中如何使用双层遍历进行数组操作，包括删除arr2中与arr1相同的对象、修改classify值、添加新对象以及处理arr1中多余的对象，展示了splice和push方法的应用。
摘要由CSDN通过智能技术生成

js中，数组对象操作——双层遍历-for循环之splice-删除、push-添加 & 数组中添加对象 & 删除数组中对象 & 数组中对象的参数值置空

index.js

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Document</title>
  </head>

  <body>
    <script>
      // 场景1
      // arr1和arr2中，classify和workerCode相同，不往arr2中添加arr1中的对象；workerCode相同，classify不同，arr2中的classify值改为'1'；arr1对中对象的workerCode，arr2中没有，这个对象直接添加到arr2中
      // let arr1 = [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      //   { classify: "1", workerCode: 17 },
      // ];

      // let arr2 = [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      //   { classify: "2", workerCode: 17 },
      //   { classify: "3", workerCode: 35 },
      // ];
      // for (let i = 0; i < arr1.length; i++) {
      //   let found = false;
      //   for (let j = 0; j < arr2.length; j++) {
      //     if (
      //       arr1[i].classify === arr2[j].classify &&
      //       arr1[i].workerCode === arr2[j].workerCode
      //     ) {
      //       found = true;
      //       break;
      //     } else if (
      //       arr1[i].workerCode === arr2[j].workerCode &&
      //       arr1[i].classify !== arr2[j].classify
      //     ) {
      //       arr2[j].classify = "1";
      //       found = true;
      //       break;
      //     }
      //   }
      //   if (!found) {
      //     arr2.push(arr1[i]);
      //   }
      // }
      // console.log(arr2);
      // [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      //   { classify: "1", workerCode: 17 },
      //   { classify: "3", workerCode: 35 },
      // ];

      // 场景2
      // arr1和arr2中，classify和workerCode相同，不往arr2中添加arr1中的对象；workerCode相同，classify不同，arr2中的classify值改为'1'；arr1对中对象的workerCode，arr2中没有，这个对象直接添加到arr2中
      // let arr1 = [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      //   { classify: "1", workerCode: 17 },
      // ];

      // let arr2 = [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      //   { classify: "2", workerCode: 17 },
      //   { classify: "3", workerCode: 35 },
      // ];
      // for (let i = 0; i < arr1.length; i++) {
      //   let found = false;
      //   for (let j = 0; j < arr2.length; j++) {
      //     if (
      //       arr1[i].classify === arr2[j].classify &&
      //       arr1[i].workerCode === arr2[j].workerCode
      //     ) {
      //       found = true;
      //       break;
      //     } else if (
      //       arr1[i].workerCode === arr2[j].workerCode &&
      //       arr1[i].classify !== arr2[j].classify
      //     ) {
      //       arr2[j].classify = "1";
      //       found = true;
      //       break;
      //     }
      //   }
      //   if (!found) {
      //     arr2.push(arr1[i]);
      //   }
      // }
      // console.log(arr2);
      //场景3
      //arr1和arr2中，classify和workerCode相同，不往arr2中添加arr1中的对象；workerCode相同，classify不同，arr2中的classify值改为'1'；arr1对中对象的workerCode，arr2中没有，这个对象直接添加到arr2中；arr2对中对象的classify为‘1’且该对象的workerCodearr1中没有，则删除arr2中该对象
      // let arr1 = [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      //   { classify: "1", workerCode: 17 },
      // ];

      // let arr2 = [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      //   { classify: "2", workerCode: 17 },
      //   { classify: "3", workerCode: 35 },
      // ];
      // for (let i = 0; i < arr1.length; i++) {
      //   let found = false;
      //   for (let j = 0; j < arr2.length; j++) {
      //     if (
      //       arr1[i].classify === arr2[j].classify &&
      //       arr1[i].workerCode === arr2[j].workerCode
      //     ) {
      //       found = true;
      //       break;
      //     } else if (
      //       arr1[i].workerCode === arr2[j].workerCode &&
      //       arr1[i].classify !== arr2[j].classify
      //     ) {
      //       arr2[j].classify = "1";
      //       found = true;
      //       break;
      //     }
      //   }
      //   if (!found) {
      //     arr2.push(arr1[i]);
      //   }
      // }

      // for (let i = 0; i < arr2.length; i++) {
      //   let found = false;
      //   for (let j = 0; j < arr1.length; j++) {
      //     if (
      //       arr2[i].classify === "1" &&
      //       arr2[i].workerCode === arr1[j].workerCode
      //     ) {
      //       found = true;
      //       break;
      //     }
      //   }
      //   if (!found && arr2[i].classify === "1") {
      //     arr2.splice(i, 1);
      //     i--;
      //   }
      // }
      // console.log(arr2);
      // 场景4
      // 删除arr1中比arr2中多的对象
      // let arr1 = [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      //   { classify: "1", workerCode: 17 },
      // ];

      // let arr2 = [
      //   { classify: "1", workerCode: 15 },
      //   { classify: "1", workerCode: 16 },
      // ];
      // for (let i = 0; i < arr1.length; i++) {
      //   let found = false;
      //   for (let j = 0; j < arr2.length; j++) {
      //     if (
      //       arr1[i].classify === arr2[j].classify &&
      //       arr1[i].workerCode === arr2[j].workerCode
      //     ) {
      //       found = true;
      //       break;
      //     }
      //   }
      //   if (!found) {
      //     arr1.splice(i, 1);
      //     i--;
      //   }
      // }
      // console.log(arr1);
      // 场景5
      // arr1中比arr2中多的对象，classify值改为空字符串
      let arr1 = [
        { classify: "1", workerCode: 15 },
        { classify: "1", workerCode: 16 },
        { classify: "1", workerCode: 17 },
      ];

      let arr2 = [
        { classify: "1", workerCode: 15 },
        { classify: "1", workerCode: 16 },
      ];
      for (let i = 0; i < arr1.length; i++) {
        let found = false;
        for (let j = 0; j < arr2.length; j++) {
          if (
            arr1[i].classify === arr2[j].classify &&
            arr1[i].workerCode === arr2[j].workerCode
          ) {
            found = true;
            break;
          }
        }
        if (!found) {
          arr1[i].classify = "";
        }
      }
      console.log(arr1);
    </script>
  </body>
</html>
viceen
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JS的splice()方法在for循环中使用
weixin_45178761的博客
03-25 1716
在写JS代码时，我们常常使用 splice 函数来删除数组中的元素，因为 splice 函数会直接对数组进行修改，从而不需再自己写一个算法来移动数组中的其他元素填补到被删除的位置。介绍 splice 的删除数组元素的用法，和在 for 循环中使用 splice 时遇到的问题。 在使用 splice 之前，必备条件是，要先有一个数组。。。 var arr = new Array(1, 2, 3, 4...
JS中彻底删除对象组成的数组中的元素
01-08
在 JS 中，列举一个由对象组成的数组，例如： var arrobj = [{ a: 1, b: 2 }, { c: 3, d: 4 }, { name: &#39;linzhu&#39;, age:22}]; 如果我们想要删除其中的第二个对象，应该怎么做呢？其实方法和操作数组完全相同。 在最开始的时候我尝试使用了 delete 运算符，但在查询数组长度的时候发现其实这种方法并不是彻底删除元素，而是删除它的值，但仍会保留空间。 var arrobj = [{ a: 1, b: 2 }, { c: 3, d: 4 }, { name: &#39;linzhu&#39;, age: 22 }]; c
JS遍历数组向数组中对象添加属性
WYB_BOOM的博客
09-15 1007
Object.assign({},item,{hasChildren:true})
js数组两层遍历
frank_fong的博客
01-10 4340
&lt;!DOCTYPE html&gt; &lt;html lang="zh-CN"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;meta name="viewport" content="width=device-width, initial-scale=1.0"&gt; &lt;meta http-equiv...
双重数组遍历，根据两个数组对象种某一个值相等作为判断条件过滤数组
weixin_38912662的博客
04-19 1090
双重数组遍历，根据两个数组对象种某一个值相等作为判断条件过滤数组 let tableData=[{a:1,b:2,c:3},{a:2,b:3,c:4},{a:3,b:4,c:5},{a:4,b:5,c:6}] let queryList= [{a:1,d:2},{a:3,d:4},{a:5,d:6},{a:7,d:8},] let newArr = tableData.filter(item =&gt; { if(queryList.findIndex(iten =&gt; i
遍历双层循环嵌套的数组--使用 ... 扩展运算符
weixin_45392559的博客
08-30 692
遍历双层循环嵌套的数组--使用 ... 扩展运算符
Vue实现动态添加或者删除对象和对象数组的操作方法
10-17
在Vue.js框架中，动态添加或删除对象和对象数组是常见的需求，特别是在处理表单数据、列表展示等场景。本文将详细讲解如何在Vue项目中实现这一功能。 首先，我们来看一下添加对象到对象数组的核心代码： ```...
arrsplice.js，js删除数组中指定元素-splice
04-11
js删除数组中指定元素--splice 注意：splice() 方法会改变原始数组。 如果要保留原始数组并返回新的数组， 请使用 Array.filter() 方法。
JS在Array数组中按指定位置删除或添加元素对象方法示例
12-13
JavaScript的数据中可通过splice/slice在指定位置添加或删除元素。另外还有slice、delete等方法实现。 splice简介 splice方法向/从数组中添加/删除项目，然后返回被删除的项目。&nbsp;该方法会改变原始数组。 array...
Vue响应式添加、修改数组和对象的值
10-20
在Vue.js框架中，响应式系统是其核心特性之一，它使得数据变化能够自动更新视图。然而，由于JavaScript的内在限制，Vue无法自动检测到数组和对象的部分变更。当直接修改数组元素或对象属性时，Vue的响应式机制可能...
两层数组广度优先数据遍历
weixin_30569033的博客
04-24 120
　　当需要轮训取多个分类数据的时候，每个分类一个数组，每个分类取一个再取下一个。 遍历方式总结如下： 　　 List&lt;List&lt;String&gt;&gt; list = new ArrayList&lt;List&lt;String&gt;&gt;(); int jLeng = 0; for (int i = 0; i &lt; skuList.si...
数组的遍历
yakelande的博客
03-12 427
数组位置 //从头遍历元素在数组中的位置，如果没有找到则返回-1 var arr=['hao','hi','hello','nihao','nice']; var str=arr.indexOf('nihao'); console.log(str); //3 //从末尾遍历元素在数组中的位置，如果没有找到则返回-1 var arr=['hao','...
JS基础学习（七）：对象和数组进行循环、concat、splice、indexOf、push、unshift、pop、shift、confirm
m0_64460142的博客
04-25 1638
1.对象和数组进行循环 例如： &lt;script&gt; // ①for in 对象和数组进行循环 let obj = { name: 'XXX', //数组obj下name属性的值为‘xxx’ age: 22,//数组obj下age属性的值...
JS中splice()方法在for循环中踩坑记录
前端菜鸟
03-06 1326
slice()方法，删除数组中某一项的时候，直接改变的就是原数组，这个值被删掉以后，删除的值后面的值就会向前移动一位，后一位值的索引就变成删掉值的索引，而对于for循环来说，这个索引已经循环过了，而后一位值也会被跳过循环。
【js splice】在循环数组中 删除掉 某些项
AAAXiaoApple的博客
05-24 375
【代码】【js splice】在循环数组中 删除掉 某些项。
【解决】js for循环splice()方法删除数组中的元素会被跳过或者只能删除部分
热门推荐
weichun
12-24 1万+
根据特定的条件，要删除数组中的一些值，用了for循环和splice()方法，结果遇到了问题，有些数据本该删掉的数据却保留了下来，像是被splice()方法故意跳过一样。 仔细研究了一下splice()： “splice() 方法用于添加或删除数组中的元素，注意：这种方法会改变原始数组。” 举例： let arr = [ {id:1,name:'Tom',sex:0}, {id:2...
剑指offer.40.数组中只出现1次的数字
qq_43249684的博客
09-14 130
剑指offer.40.数组中只出现1次的数字 题目描述 一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。 代码实现 //num1,num2分别为长度为1的数组。传出参数 //将num1[0],num2[0]设置为返回结果 public class Solution { public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) { int mask = 0;
JS的splice()方法在for循环中使用可能会遇到的坑
xyl的博客
12-20 1144
在写JS代码时，我们常常使用 splice 函数来删除数组中的元素，因为 splice 函数会直接对数组进行修改，从而不需再自己写一个算法来移动数组中的其他元素填补到被删除的位置。splice 功能十分强大，除了可以删除数组的元素之外，还可以删除的同时添加新的元素到删除的位置等等用法。在本篇文章中，我只介绍 splice 的删除数组元素的用法，和在 for 循环中使用 splice 时遇到过的坑，作为记录以免我下次忘记了这个坑。 在使用 splice 之前，必备条件是，要先有一个数组。。。 var a
js遍历数组，并删除符合条件的数组对象
最新发布
07-13
1. 使用 `for` 循环遍历数组，并使用 `splice()` 方法删除符合条件的数组对象。需要注意的是，由于 `splice()` 方法会改变数组的长度和索引，因此在删除元素后需要将索引递减。 ```javascript let arr = [1, 2, 3, 4...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值