1. Mit der Methode some() wird ermittelt, ob die Elemente im Array die angegebenen Bedingungen erfüllen (von der Funktion bereitgestellt).
Typ: array.some( function ( item, index, arr) {} ,thisValue)
Die Methode some() führt nacheinander jedes Element des Arrays aus:
- Wenn ein Element die Bedingung erfüllt, gibt der Ausdruck „true“ zurück und die übrigen Elemente werden nicht erneut überprüft.
- Gibt false zurück, wenn kein Element vorhanden ist, das die Bedingung erfüllt.
Hinweis: some() prüft nicht auf leere Arrays.
Hinweis: some() verändert das ursprüngliche Array nicht.
const blobs = [
"application/x-download",
"application/vnd.ms-excel",
"application/msword",
"application/octet-stream",
];
request.interceptors.response.use(async (response, request) => {
const contentType = response.headers.get("Content-Type");
const isBlob = blobs.some((item) => contentType?.includes(item));
if (isBlob) {
request.responseType = "blob";
return response;
}
const { error, code, status, msg, data } = await response.clone().json();
if ((code === 200 || code === 202) && !error) return response;
throw {
response: {
status: code || status,
statusText: msg,
data: data,
},
};
});
return request;
}Zweitens gibt es die Methode every(), die das Gegenteil der Methode some() ist
Mit der Methode every() wird überprüft, ob alle Elemente des Arrays die angegebene Bedingung (bereitgestellt durch die Funktion) erfüllen.
Beschreibung:array.every( function ( item, index, arr) {} ,thisValue)
Die Methode every() überprüft alle Elemente im Array mithilfe der angegebenen Funktion:
Wenn festgestellt wird, dass ein Element im Array nicht zufriedenstellend ist, gibt der gesamte Ausdruck „false“ zurück und die übrigen Elemente werden nicht überprüft.
Gibt true zurück, wenn alle Elemente die Bedingung erfüllen.
Hinweis: every() prüft nicht auf leere Arrays.
Hinweis: every() verändert nicht das ursprüngliche Array.
const list = [10, 12, 8, 12];
if (list.every((number) => number > 9)) {
//代码块
}
//因为8小于9 所以返回false
3. Reduce()-Methode
Empfängt eine Funktion als Akkumulator und jeder Wert im Array (von links nach rechts) wird zunächst reduziert und schließlich zu einem Wert berechnet.
Beschreibung: array.reduce( function( total, currentValue, currentIndex, arr ), initialValue )
array .reduce(callback,[initialValue])
Reduce führt der Reihe nach die Callback-Funktion für jedes Element im Array aus, schließt Elemente aus, die gelöscht wurden oder denen noch nie ein Wert im Array zugewiesen wurde, und akzeptiert vier Parameter: Anfangswert (oder letzter Callback). Funktionsrückgabewert), der aktuelle Elementwert, der aktuelle Index, das Array, für das Reduce aufgerufen wurde.
Rückruf (Funktion, die für jeden Wert im Array ausgeführt wird, mit vier Parametern)
1. previousValue (der vom letzten Callback-Aufruf zurückgegebene Wert oder der bereitgestellte Anfangswert (initialValue))
2. currentValue (das aktuell verarbeitete Element im Array)
3. index (der Index des aktuellen Elements im Array)
4 . array (Das Array, für das Reduce aufgerufen wird)
initialValue (Als erstes Argument für den ersten Callback-Aufruf.)
Notiz:
1. Reduce() führt die Rückruffunktion nicht für ein leeres Array aus.
2. Wenn initialValue angegeben wird, ist previousvalue initialValue, wenn die Callback-Funktion zum ersten Mal ausgeführt wird, und currentValue ist das erste Element im Array. Wenn kein Anfangswert angegeben wird, ist previousvalue das erste Element im Array und currentValue das zweite Element im Array.
Gängige Reduzierungsmethoden (vorzugsweise Standardwerte festlegen)
1. Array-Summierung, Produkt
let numbers = [1, 2, 3, 4, 5]
let result1 = numbers.reduce((sum, n) => sum + n, 0)
console.log(result1); // 15
// let result2 = numbers.reduce((sum, n) => sum * n)
let result2 = numbers.reduce((sum, n) => sum * n, 1)
console.log(result2); // 120
2. Akkumulieren Sie den Wert der Objekte im Array
let numberObj = [{n: 1}, {n: 2}, {n: 3}, {n: 4}, {n: 5}]
let result3 = numberObj.reduce((sum, obj) => sum + obj.n, 0)
console.log(result3); // 15
3. Zählen Sie die Anzahl der Vorkommen jedes Elements im Array
let colors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'purple', 'red']
let countColor = colors.reduce(function(allColors, color){
if(color in allColors) {
allColors[color]++;
} else {
allColors[color] = 1;
}
return allColors;
}, {});
console.log(countColor); // {blue: 1, green: 1, indigo: 1, orange: 1, purple: 1, red: 2, yellow: 1}
4. Array-Deduplizierung
let arr = [1, 2, 3, 4, 4, 1]
let newArr = arr.reduce((pre,cur)=>{
if(!pre.includes(cur)){
return pre.concat(cur)
}else{
return pre
}
},[])
console.log(newArr); // [1, 2, 3, 4]
5. Konvertieren Sie ein zweidimensionales Array in ein eindimensionales Array
let twoArray = [[0, 1], [2, 3], [4, 5]]
let oneArray = twoArray.reduce((arr, val) => arr.concat(val), [])
console.log(oneArray); // [0, 1, 2, 3, 4, 5]
6. Konvertieren Sie ein mehrdimensionales Array in ein eindimensionales
let moreArr = [[0, 1], [2, 3], [4,[5,6,7]]]
const resultArr = function(moreArr){
return moreArr.reduce((pre,cur) => pre.concat(Array.isArray(cur) ? resultArr(cur) : cur), [])
}
console.log(resultArr(moreArr)); // [0, 1, 2, 3, 4, 5, 6, 7]
7. Klassifizieren Sie Objekte nach ihren Attributen
let peopleInfo = [
{name: 'aaa', age: 15, sex: '男'},
{name: 'bbb', age: 16, sex: '女'},
{name: 'ccc', age: 15, sex: '女'}
]
function groupBy(objectArray, property) {
return objectArray.reduce((resultObj, obj) => {
var key = obj[property]
if(!resultObj[key]) {
resultObj[key] = []
}
resultObj[key].push(obj)
return resultObj;
}, {})
}
let peopleAgeGroup = groupBy(peopleInfo, 'age')
console.log(peopleAgeGroup); // {15: [{name: "aaa", age: 15, sex: "男"}, {name: "ccc", age: 15, sex: "女"}],16: [{name: "bbb", age: 16, sex: "女"}]}
let peopleSexGroup = groupBy(peopleInfo, 'sex')
console.log(peopleSexGroup); // {男: [{name: "aaa", age: 15, sex: "男"}], 女: [{name: "bbb", age: 16, sex: "女"}, {name: "ccc", age: 15, sex: "女"}]}Verweise
1. Die some()-Methode in JS_js some_Shen Yichengs Blog-CSDN-Blog