js数组操作常用的方法,删除指定元素、去除空值、是否包含另一个数组、去重

博客聚焦于JavaScript的数组操作,介绍了从数组中删除指定元素、去除空值、判断数组是否包含另一个数组以及数组去重等实用技巧,为开发者提供了处理数组的有效方法。

1、从数组中删除某一个指定的元素

    Array.prototype.remove = function (val) {
      let index = this.indexOf(val);
      if (index > -1) {
        this.splice(index, 1);
      }
    };

2、去除数组中的空值

  Array.prototype.bouncer = function () {
      return this.filter(item => {/* fliter 返回结果是true的*/
        return item;
      });
    }
    let arr = [1, null, 2, 3, undefined, '', 4]
    console.log(arr)
    console.log(arr.bouncer())

3、 数组是否包含另一个数组

  function isContained(a, b) {
      /* 
       * a是大数组b是小数组
       * 数组是否包含另一个数组 
       */
      if (!(a instanceof Array) || !(b instanceof Array)) return false;
      if (a.length < b.length) return false;
      let aStr = a.toString();
      for (let i = 0, len = b.length; i < len; i++) {
        if (aStr.indexOf(b[i]) == -1) return false;
      }
      return true;
    }

    let arr1 = [1, 2, 3, 4, 6]
    let arr2 = [1, 2, 6, 3]
    console.log(isContained(arr1, arr2))

原型上版:

 Array.prototype.isContained = function (b) {
      if (!b instanceof Array) return false
      if (this.length < b.length) return false
      let aStr = this.toString();
      for (let i = 0, len = b.length; i < len; i++) {
        if (aStr.indexOf(b[i]) == -1) return false;
      }
      return true;
    }


    let arr1 = [1, 2, 3, 4, 6]
    let arr2 = [1, 2, 6, 3]
    console.log(arr1.isContained(arr2))

4、数组去重

  Array.prototype.uniq = function (array) {
      var temp = []; //一个新的临时数组
      for (var i = 0; i < array.length; i++) {
        if (temp.indexOf(array[i]) == -1) {
          temp.push(array[i]);
        }
      }
      return temp;
    }
    
    let arr = [1, 2, 2, 3, 4, 4, 5]
    console.log(arr)
    console.log(arr.uniq(arr))
<think>好的,用户想了解如何从一个数组中移除一个数组中存在的元素。我需要先理解他的需求,然后根据提供的引用资料找到合适的解决方法。 首先,用户提到的引用[1]是关于找出只出现一次的元素,使用异或操作,但可能适用这里的情况。引用[2]和[3]则更相关,其中引用[2]是Java中比较两个数组,找出在对方中的元素,引用[3]是JavaScript中使用filter和find方法过滤数组对象。 用户的问题可能涉及同编程语言,所以需要分别给出同语言的实现方法。比如在Java中可以使用集合的差集操作,或者遍历数组逐个检查。在JavaScript中,可以用filter和includes或者find方法。Python的话,可以用列表推导式配合集合来提高效率。 需要考虑到时间复杂度和空间复杂度。比如直接遍历两个数组的时间复杂度是O(n*m),如果使用哈希集合,可以降到O(n + m)。对于大据量,性能优化很要。 外,用户可能希望看到具体的代码示例,所以每个方法都要给出代码片段,并解释优缺点。例如,Java中的循环方法适合小数组,而使用HashSet适合较大的数组JavaScript中使用filter和find可能效率高,但代码简洁,或者使用Set来优化。 还要注意处理元素的情况。比如,如果原数组元素是否需要全部移除,还是保留未被包含的部分。例如,数组A是[1,2,2,3],数组B是[2],那么结果应该是[1,3]吗?这时候需要明确需求,但用户的问题描述是排除一个数组存在的元素,所以每个元素只要在一个数组中出现过,就全部移除。 最后,总结方法的适用场景,帮助用户根据实际情况选择合适的方法。比如,据量小的话可以用简单遍历,据量大则用集合优化。</think>### 如何从一个数组中排除一个数组包含元素? #### 方法一:遍历比较法(适用于所有语言) **实现思路**: 1. 遍历第一个数组中的每一个元素 2. 对每个元素检查是否存在于第二个数组中 3. 仅保留存在于第二个数组中的元素 **Java实现**: ```java public static int[] arrayDifference(int[] arr1, int[] arr2) { List<Integer> result = new ArrayList<>(); for (int num : arr1) { boolean exists = false; for (int check : arr2) { if (num == check) { exists = true; break; } } if (!exists) { result.add(num); } } return result.stream().mapToInt(i->i).toArray(); } ``` **时间复杂度**:$O(n \times m)$(适用于小规模据) #### 方法二:集合优化法(推荐) **实现思路**: 1. 将第二个数组转换为哈希集合 2. 遍历第一个数组时使用集合快速判断存在性 **Java实现**: ```java public static int[] optimizedDifference(int[] arr1, int[] arr2) { Set<Integer> set = new HashSet<>(); for (int num : arr2) { set.add(num); } return Arrays.stream(arr1) .filter(num -> !set.contains(num)) .toArray(); } ``` **时间复杂度**:$O(n + m)$(推荐用于大规模据) **JavaScript实现**: ```javascript function arrayDifference(arr1, arr2) { const set = new Set(arr2); return arr1.filter(item => !set.has(item)); } ``` #### 方法三:排序+双指针(适用于有序据) **实现思路**: 1. 先对两个数组进行排序 2. 使用双指针同时遍历两个数组 **Python实现**: ```python def array_difference(arr1, arr2): arr1_sorted = sorted(arr1) arr2_sorted = sorted(arr2) i = j = 0 result = [] while i < len(arr1_sorted) and j < len(arr2_sorted): if arr1_sorted[i] < arr2_sorted[j]: result.append(arr1_sorted[i]) i += 1 elif arr1_sorted[i] > arr2_sorted[j]: j += 1 else: i += 1 j += 1 while i < len(arr1_sorted): result.append(arr1_sorted[i]) i += 1 return result ``` #### 各方法对比 | 方法 | 时间复杂度 | 空间复杂度 | 适用场景 | |------------|------------|------------|--------------------------| | 遍历比较 | $O(n^2)$ | $O(1)$ | 小规模据 | | 集合优化 | $O(n)$ | $O(m)$ | 通用场景(推荐) | | 排序双指针 | $O(n\log n)$ | $O(n)$ | 已排序或需要多次查询的据 | #### 注意事项 1. **元素处理**:上述方法会保留所有未被排除的元素。如果需要去除元素,需要额外处理 2. **对象比较**:对于对象数组,需要自定义比较逻辑(如引用[3]中的`id`比较) 3. **空值处理**:需要考虑数组中可能存在的`null`或`undefined`值
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值