js向数组中添加不重复元素的方法封装

可以使用 Set 数据结构来判断元素是否重复，然后将其转化为数组。以下是封装的代码：

function addDistinctItem(arr, item) {
const set = new Set(arr);
if (!set.has(item)) {
arr.push(item);
}
return arr;
}

调用方式为：

const arr = [1, 2, 3];
addDistinctItem(arr, 2); // [1, 2, 3]
addDistinctItem(arr, 4); // [1, 2, 3, 4]

相关问题

二分法查找，也称折半查找，是一种在有序数组中查找特定元素的搜索算法。查找过程可以分为以下步骤： （1）首先，从有序数组的中间的元素开始搜索，如果该元素正好是目标元素（即要查找的元素），则搜索过程结束，否则进行下一步。 （2）如果目标元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半区域查找，然后重复第一步的操作。 （3）如果某一步数组为空，则表示找不到目标元素。 7) 封装binary_search(arr, key)，使用非递归算法，实现二分查找，返回目标元素的索引值 8) 封装binary_search(arr,low, high, key)，使用递归算法，实现二分查找，返回目标元素的索引值

好的，下面是实现二分查找的代码：

1. 非递归算法：

function binary_search(arr, key) {
  let low = 0;
  let high = arr.length - 1;
  while (low <= high) {
    const mid = Math.floor((low + high) / 2);
    if (arr[mid] === key) {
      return mid;
    } else if (arr[mid] < key) {
      low = mid + 1;
    } else {
      high = mid - 1;
    }
  }
  return -1;
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8];
console.log(binary_search(arr, 5)); // 4
console.log(binary_search(arr, 10)); // -1

2. 递归算法：

function binary_search(arr, low, high, key) {
  if (low > high) {
    return -1;
  }
  const mid = Math.floor((low + high) / 2);
  if (arr[mid] === key) {
    return mid;
  } else if (arr[mid] < key) {
    return binary_search(arr, mid + 1, high, key);
  } else {
    return binary_search(arr, low, mid - 1, key);
  }
}

const arr = [1, 2, 3, 4, 5, 6, 7, 8];
console.log(binary_search(arr, 0, arr.length - 1, 5)); // 4
console.log(binary_search(arr, 0, arr.length - 1, 10)); // -1

需要注意的是，二分查找只适用于有序数组，并且在数组中查找特定元素的时间复杂度为 O(logn)，效率非常高。

js使用原型封装everyr函数

### 回答1：
可以使用原型链来封装一个 `everyr` 函数，该函数能够模拟 Array 原型上的 `every` 方法，但是它会从数组的末尾开始遍历。代码如下：

Array.prototype.everyr = function(callback, thisArg) {
  // 获取数组的长度
  var length = this.length;

  // 如果没有传入回调函数，则抛出错误
  if (typeof callback !== 'function') {
    throw new TypeError(callback + ' is not a function');
  }

  // 从数组的末尾开始遍历
  for (var i = length - 1; i >= 0; i--) {
    // 判断是否存在当前元素
    if (this.hasOwnProperty(i)) {
      // 调用回调函数
      if (!callback.call(thisArg, this[i], i, this)) {
        // 如果回调函数返回 false，则返回 false
        return false;
      }
    }
  }

  // 如果所有元素都通过了回调函数的检查，则返回 true
  return true;
};

这个函数中，我们先获取数组的长度，然后从数组的末尾开始遍历。在每次循环中，我们检查是否存在当前元素，然后调用回调函数，并判断回调函数的返回值。如果回调函数返回 false，则说明当前元素不符合条件，我们直接返回 false。如果所有元素都符合条件，则返回 true。

### 回答2：
在JavaScript中，我们可以使用原型封装一个名为everyr的函数。everyr函数的作用是判断数组中的每一个元素是否都满足某个条件，如果都满足则返回true，否则返回false。

首先，我们可以在Array的原型对象上添加一个everyr方法。代码如下：

Array.prototype.everyr = function (callback) {
  for (let i = 0; i < this.length; i++) {
    if (!callback(this[i], i, this)) {
      return false; // 如果有一个元素不满足条件，则返回false
    }
  }
  return true; // 如果所有元素都满足条件，则返回true
};

然后，我们可以在代码中使用everyr方法来判断数组中的每一个元素是否都是偶数。代码如下：

const arr = [2, 4, 6, 8, 10];

const isEven = arr.everyr(function (item) {
  return item % 2 === 0;
});

console.log(isEven); // 输出 true

在上面的代码中，我们首先定义了一个数组arr，然后使用everyr方法来判断数组中的每一个元素是否都是偶数。在everyr的回调函数中，我们使用了取余运算符来判断元素是否是偶数。最后，将结果保存在isEven变量中，并将结果输出到控制台。

通过以上的代码，我们成功地使用原型封装了一个everyr函数，并且成功地判断了数组中的每一个元素是否都是偶数。这样，我们就可以在其他地方重复使用everyr函数来判断数组中的元素是否满足特定的条件。

### 回答3：
JavaScript中的数组对象有一个内置的方法叫做`every()`，它用于检测数组中的所有元素是否都满足某个条件。如果数组中的所有元素都满足条件，那么`every()`方法返回`true`，否则返回`false`。

我们可以使用原型封装一个名为`everyr()`的函数来模拟`every()`方法的功能。下面是使用原型封装`everyr()`函数的方法：

Array.prototype.everyr = function(callback) {
  for (let i = 0; i < this.length; i++) {
    if (!callback(this[i], i, this)) {
      return false;
    }
  }
  return true;
};

在上面的代码中，我们通过给`Array.prototype`对象添加一个名为`everyr`的方法来实现。

`everyr()`函数接收一个回调函数作为参数，该回调函数用于对数组中的每个元素进行验证。回调函数接收三个参数：当前元素的值、当前元素的索引和数组对象本身。

在`everyr()`函数内部，我们使用`for`循环遍历数组中的每个元素。如果回调函数返回值为`false`，表示当前元素不满足条件，我们则立即返回`false`。只有当所有元素都满足条件时，才会最终返回`true`。

通过原型封装`everyr()`函数后，我们可以在任何数组上使用它，就像使用原生的`every()`方法一样，例如：

const arr = [1, 2, 3, 4, 5];

const result = arr.everyr((elem) => elem > 0);

console.log(result); // 输出：true

在上面的示例中，我们首先定义了一个数组`arr`，然后使用`everyr()`方法检查数组中的每个元素是否大于0。由于所有元素都满足这个条件，所以最终返回`true`。

总结起来，我们可以通过原型封装一个名为`everyr()`的函数来模拟JavaScript的`every()`方法，它能够对数组中的元素进行条件判断并返回一个布尔值。