微信小程序数组

常用函数

concat(): 连接两个或多个数组，返回连接后的新数组。
示例：const arr1 = [1, 2, 3]; const arr2 = [4, 5, 6]; const arr3 = arr1.concat(arr2); // 返回 [1, 2, 3, 4, 5, 6]

copyWithin(): 从数组指定位置开始替换指定长度的元素。
示例：const arr = [1, 2, 3, 4, 5]; arr.copyWithin(0, 3, 4); // 将数组 [4] 替换到数组起始位置，返回 [4, 2, 3, 4, 5]

entries(): 返回一个数组迭代器，可以遍历数组中的键值对。
示例：const arr = [‘a’, ‘b’, ‘c’]; const iterator = arr.entries(); for (const [index, value] of iterator) { console.log(index, value); } // 输出：0 “a”, 1 “b”, 2 “c”

every(): 检测数组中的所有元素是否符合指定条件，返回布尔类型的值。
示例：const arr = [1, 2, 3]; const result = arr.every((value) => value > 0); // result 为 true

fill(): 用指定的值填充数组的所有元素。
示例：const arr = [1, 2, 3]; arr.fill(0); // 返回 [0, 0, 0]

filter(): 返回一个新数组，包含符合条件的原数组元素。
示例：const arr = [1, 2, 3, 4]; const result = arr.filter((value) => value % 2 === 0); // 返回 [2, 4]

find(): 返回数组中符合条件的第一个元素，否则返回 undefined。
示例：const arr = [1, 2, 3, 4]; const result = arr.find((value) => value > 2); // result 为 3

findIndex(): 返回数组中符合条件的第一个元素的索引，否则返回 -1。
示例：const arr = [1, 2, 3, 4]; const result = arr.findIndex((value) => value > 2); // result 为 2

flat(): 返回一个新数组，将多维数组拍平为一维数组。
示例：const arr = [1, [2, [3, 4]]]; const result = arr.flat(); // 返回 [1, 2, 3, 4]

forEach(): 对数组中的每个元素执行指定的操作。
示例：const arr = [1, 2, 3]; arr.forEach((value, index) => { console.log(value, index); }); // 输出：1 0, 2 1, 3 2

includes(): 返回一个布尔值，表示数组中是否包含指定元素。
示例：const arr = [1, 2, 3]; const result = arr.includes(2); // result 为 true

indexOf(): 返回数组中指定元素的第一个索引，如果不存在，返回 -1。
示例：const arr = [1, 2, 3]; const result = arr.indexOf(2); // result 为 1

join(): 将数组中的所有元素连接成一个字符串。
示例：const arr = [1, 2, 3]; const result = arr.join(); // 返回 “1,2,3”

keys(): 返回一个数组迭代器，可以遍历数组的索引。
示例：const arr = [‘a’, ‘b’, ‘c’]; const iterator = arr.keys(); for (const index of iterator) { console.log(index); } // 输出：0, 1, 2

lastIndexOf(): 返回数组中指定元素的最后一个索引，如果不存在，返回 -1。
示例：const arr = [1, 2, 2, 3]; const result = arr.lastIndexOf(2); // result 为 2

map(): 返回一个新数组，每个元素都是对原数组中的元素执行指定操作后的结果。
示例：const arr = [1, 2, 3]; const result = arr.map((value) => value *

微信小程序中的数组有许多常用的方法和用法

模糊查询

   var backendData = [];

 // 定义一个方法来执行模糊查询
    function fuzzySearch(keyword) {
      // 使用 filter 方法筛选包含关键字的元素
      const result = backendData.filter(item => {
        // 检查 name 属性是否存在，并且是一个字符串
        if (item.userName && typeof item.userName === 'string') {
          // 将字符串都转为小写进行比较，实现不区分大小写的模糊查询
          return item.userName.toLowerCase().includes(keyword.toLowerCase());
        }
        return false;
      });
      return result;
    }
var list = []; 
const searchResult = fuzzySearch(list);

精确查询

function exactSearch(keyword) {
  const result = backendData.filter(item => {
    if (item.userName && typeof item.userName === 'string') {
      // 将字符串都转为小写进行比较，实现不区分大小写的精确查询
      return item.userName.toLowerCase() === keyword.toLowerCase();
    }
    return false;
  });
  return result;
}
var list = [];
const searchResult = exactSearch(list);
---------------------------只比较整数类型的属性-----------------------------------

    function exactSearch(keyword) {

      const result = backendData.filter(item => {

        if (Number.isInteger(item.grad)) {

           // 只比较整数类型的属性

         return item.grad === parseInt(keyword);

        }

        return false;

      });

      return result;

    }

数组中找到对应的对象

//数组中找到对应的对象
 let list =  this.data.Teacher.find(item => item.userId === e.currentTarget.dataset.id);  //list是对象

数组中找到满足指定条件的所有元素

let list = this.data.Teacher.filter(item => item.userId === e.currentTarget.dataset.id);  //list是集合

数组中的每个元素克隆到一个新对象中，并给新对象添加一个新的字段

      const modifiedList = this.data.list.map(item => {
        // 给每一项添加一个新的字段
        return {
          ...item,
          static: 0
        };
      });
--------------------------------------------------------------------
      let newList = this.data.prodectList.map(item => ({
        ...item,
        static: 1
      }));
--------------------------------------------------------------------
第二段代码使用了对象的展开运算符 ...，而第一段代码使用了传统的对象属性赋值方式。

两种方式都可以实现相同的效果，最终都会生成一个新的数组，其中包含原数组元素的深拷贝，并且在新对象中添加了新的字段。

如果你想将一个新的集合与旧的集合拼接在一起，并且当新集合中的数据的id与旧集合中的数据相同时进行过滤去除

// 假设旧集合为oldCollection，新集合为newCollection

// 使用 Set 数据结构来保存旧集合中的id
const oldIds = new Set();
oldCollection.forEach(item => {
  oldIds.add(item.id);
});

// 过滤新集合中与旧集合中相同id的数据
const filteredCollection = newCollection.filter(newItem => {
  return !oldIds.has(newItem.id);
});

// 将过滤后的新集合与旧集合拼接在一起
const mergedCollection = oldCollection.concat(filteredCollection);

集合数据按时间（字段）重新排序

let sortedList = that.data.oldClassList.sort((a, b) => new Date(b.datetime) - new Date(a.datetime))

更新中 ----