一個數組合并到一個數組：https://blog.csdn.net/qq_43071699/article/details/142409146
//Vue.set(this.letters,2,'xxx');//要修改的數組對象，索引值，修改后的值
//Vue.set(state.stu.,'address','xxx');//要修改的單個對象，對象屬性名（key），修改后的值
//Vue.delete(state.stu,'address');//要修改的單個對象，對象屬性名（key），刪除stu里的屬性

//如果想要自定義排序規則，需要重寫sort，參考下面的代碼。
高階函數

1、filter過濾函數
filter也是一個常用的操作，它用于把Array的某些元素過濾掉，然后返回剩下的元素。
filter把傳入的函數依次作用于每個元素，然后根據返回值是true還是false決定保留還是丟棄該元素。

const nums = [2,3,5,1,77,55,100,200];
let newArray = nums.filter(function (n) {
    //小于100就是true，進入newArray數組
    return n < 100;
})
console.log(newArray);//[2,3,5,1,77,55]

2、map高階函數
map函數同樣會遍歷數組每一項，傳入回調函數為參數，num是map遍歷的每一項，回調函數function返回值會被添加到新數組中

const nums = [2,3,5,1,77,55,100,200];
let new2Array = nums.map(function (num) {
    return n*2;//每過元素都乘2
})
console.log(new2Array);//[4,6,10,2,154,110,200,400];

3、reduce高階函數
reduce函數同樣會遍歷數組每一項，傳入回調函數和‘0’為參數，0表示回調函數中preValue初始值為0，回調函數中參數preValue是每一次回調函數function返回的值，currentValue是當前值

const nums = [2,3,5,1,77,55,100,200];
let new3Array = nums.reduce(function (preValue,currentValue) {
    //數組為[2,3,5,1,77,55,100,200]，則回調函數第一次返回值為0+2=2，第二次preValue為2，返回值為2+3=5，以此類推直到遍歷完成
    return preValue+currentValue;
},0);//第二個參數0是preValue的初始值
console.log(new3Array);//443

4、sort排序算法
因為Array的sort()方法默認把所有元素先轉換為String再排序，結果'10'排在了'2'的前面，因為字符'1'比字符'2'的ASCII碼小。如果不知道sort()方法的默認排序規則，直接對數字排序，絕對栽進坑里！

//要按數字大小排序，我們可以這么寫：
var arr = [10, 20, 1, 2];
arr.sort(function (x, y) {
    if (x < y) {
        return -1;
    }
    if (x > y) {
        return 1;
    }
    return 0;
}); // [1, 2, 10, 20]

//如果要倒序排序，我們可以把大的數放前面：
var arr = [10, 20, 1, 2];
arr.sort(function (x, y) {
    if (x < y) {
        return 1;
    }
    if (x > y) {
        return -1;
    }
    return 0;
}); // [20, 10, 2, 1]

引用：http://www.rzrgm.cn/bushui/p/12213689.html

JS判斷數組是否包含某個元素
方法一：使用includes()方法
const array = [1, 2, 3, 4, 5];
const element = 3;
const isContained = array.includes(element);
console.log(isContained); // 輸出 true
方法二：使用indexOf()方法
const array = [1, 2, 3, 4, 5];
const element = 3;
const isContained = array.indexOf(element) !== -1;
console.log(isContained); // 輸出 true
方法三：使用some()方法
const array = [1, 2, 3, 4, 5];
const element = 3;
const isContained = array.some(item => item === element);
console.log(isContained); // 輸出 true
方法四：使用find()方法
const array = [1, 2, 3, 4, 5];
const element = 3;
const isContained = array.find(item => item === element) !== undefined;
console.log(isContained); // 輸出 true
方法五：使用filter()方法
const array = [1, 2, 3, 4, 5];
const element = 3;
const isContained = array.filter(item => item === element).length > 0;
console.log(isContained); // 輸出 true
這些方法都可以用來判斷數組是否包含某個元素，其中使用includes()方法和indexOf()方法更為直觀和簡潔。

JS數組操作
arrayObject.slice(start,end)
JavaScript中的slice()方法用于從數組中提取部分元素并創建一個新的數組，而不會修改原始數組。
slice()方法接受兩個參數：`start`和`end`。start參數指定了截取的開始位置（包含該位置的元素），而end參數指定了截取的結束位置（不包含該位置的元素）。
如果省略end參數，則slice()方法會截取從start位置到數組末尾的所有元素。
如果start和end參數為正數，它們表示從數組的開頭開始計數的索引位置。例如，arr.slice(1, 4)將提取數組中索引為1、2、3的元素（即包含索引1但不包含索引4的元素）。
如果start或end參數為負數，它們表示從數組的末尾開始計數的索引位置。例如，arr.slice(-2)將提取數組中倒數第二個元素。
如果不提供任何參數，slice()方法將復制整個數組并返回一個新的數組。
此外，slice()方法還支持從數組末尾開始計數的負索引。例如，arr.slice(-2, -1)將提取數組中倒數第二個元素（不包含最后一個元素）。
使用slice()方法時，需要注意的是它返回的是一個新的數組，原始數組不會被修改。這使得slice()方法在需要保留原始數據的同時，又能方便地獲取數組的某一部分。
start 必需。規定從何處開始選取。如果是負數，那么它規定從數組尾部開始算起的位置。也就是說，-1 指最后一個元素，-2 指倒數第二個元素，以此類推。
end 可選。規定從何處結束選取。該參數是數組片斷結束處的數組下標。如果沒有指定該參數，那么切分的數組包含從 start 到數組結束的所有元素。如果這個參數是負數，那么它規定的是從數組尾部開始算起的元素。
//this.letters.push('123');//在末尾添加一個元素
//this.letters.pop();//從末尾刪除一個元素
//this.letters.unshift('111');//在開端添加一個元素
//this.letters.shift();//從開端刪除一個元素
//this.letters.splice(1,2);//從下標為1的元素開始刪除兩個元素
//this.letters.splice(1,2,'777','888');//從下標為1的元素開始刪除兩個元素，并插入兩個新元素
//this.letters.splice(1, 0, '777', '888'); //在下標為1處插入兩個元素
//this.letters.splice(2);//保留前2個元素，其他的刪除掉
//this.letters.splice(0,this.letters.length);//清除數組內所有元素
//Array.prototype.push.apply(this.letters, this.letters2);//把數組letters2中的元素插入到letters的尾端
//this.letters.sort()轉為字符串后升序排序
//this.letters.reverse()轉為字符串后降序排序
//數組對象排序，比較每個對象中的字符串

排序
//這里返回的是他們的差值，如果是大于0的值，就會將b排在前面，如果小于0,就會將a排在前面，如果是0的話，就隨便。（冒泡排序法?。。?br>//升序排列

that.tableDataAll.sort((a, b) => {
  //字符串比較
   if(a.shopId == "" || a.shopId == null || b.shopId == "" || b.shopId == null){
        return (a.shopId == "" || a.shopId == null) ? 1 : -1;
    }
  return a.shopId.localeCompare(b.shopId);
});

 多條件排序

let items = [
  { name: 'Apple', type: 'fruit' },
  { name: 'Carrot', type: 'vegetable' },
  { name: 'Banana', type: 'fruit' },
  { name: 'Potato', type: 'vegetable' }
];
 
items.sort((a, b) => {
  if (a.type !== b.type) {
    // 如果類型不同，則按類型字母順序排序
    return a.type.localeCompare(b.type);
  } else {
    // 如果類型相同，則按名稱字母順序排序
    return a.name.localeCompare(b.name);
  }
});

console.log(items);

在這個例子中，首先根據type屬性排序，如果type相同，則根據name屬性排序。localeCompare方法用于比較字符串，保證了排序是區分區域的（locale-aware）。
你可以根據需要增加更多的條件來進行排序，只需在排序函數中增加相應的邏輯即可。

多條件排序方法

//多條件排序
export function sortArr(dataArr: any, sortByList: any) {
    dataArr.sort(function (x: any, y: any) {
        for (let k = 0; k < sortByList.length; k++) {
            let key: any = sortByList[k]['key'];
            let order: any = sortByList[k]['order'];
            if (order == 'asc') {
                if (x[key] > y[key]) {
                    return 1;
                }
                if (x[key] < y[key]) {
                    return -1;
                }
            } else {
                if (x[key] > y[key]) {
                    return -1;
                }
                if (x[key] < y[key]) {
                    return 1;
                }
            }
        }
        return 0;
    });
    return dataArr;
}

測試代碼

let arr1: any = [
    { id: 1, name: 'jay', age: 23 },
    { id: 2, name: 'ali', age: 12 },
    { id: 3, name: 'grace', age: 15 },
    { id: 4, name: 'blues', age: 33 },
    { id: 5, name: 'steven', age: 26 },
    { id: 6, name: 'steven', age: 8 },
  ];
  let sortByList: any = [{ key: 'name', order: 'asc' }, { key: 'age', order: 'asc' }];
  let arr2 = sortArr(arr1, sortByList);
  console.log(arr2);