Hello devs ...在这个紧凑但有用的帖子中，您会发现最常见的帖子可以与JavaScript中的数组一起使用。我们将看到的所有内容将是Kouude0，Kouude1，Kouude2，Kouude3，Kouude4，Kouude4，Kouude5，Kouude6，Kouude7，Kouude7，Kouude7，Kouude9，Kouude9，Kouude10，Kouude11，Kouude11，find，find，Kude9 Kouude9 Kouude14，Kouude15，Kouude15，Kouude16和Kouude16和Kouude16和p.udude16 and p.ude11。
方法
进入主题之前，重要的是要知道，其中一些失毒者都直接将原始阵列变为导致其值或属性的变化。另一方面，我们所有的都不突变或更改原始数组，但它们从原始数组中创建了一个新数组。
因此
pop (muta)
整个kude0消除了数组的最后一个元素，并返回被删除的元素。 MéAllpop（）突变原始数组，也就是说，它修改了其应用的数组。如果数组为空，则整个pop（）不会进行任何参数，例如：
const miArray = [1, 2, 3, 4, 5];
const elementoEliminado = miArray.pop();
console.log(miArray); // [1, 2, 3, 4]
console.log(elementoEliminado); // 5
在上一个示例中，pop（）消除了miarray阵列的最后一个元素（值为5），并因此返回该值。原始数组已修改，现在其长度为4。
push (muta)
mâmall push（）允许您在数组末尾添加一个或多个元素。该misma突变原始数组，即它修改了应用到的阵列。 mâ©all push（）需要一个或多个参数并返回数组的更新长度。
const miArray = [1, 2, 3];
const nuevaLongitud = miArray.push(4, 5);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(nuevaLongitud); // 5
在上一个示例中，push（）在数组Miarray的末尾添加值4和5，并返回数组的新长度。
unshift (muta)
MéAllunshift（）允许您在数组开始时添加一个或多个元素。 MéAllunshift（）突变原始数组，也就是说，它修改了其应用的数组。像整个kude1一样
const miArray = [3, 4, 5];
const nuevaLongitud = miArray.unshift(1, 2);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(nuevaLongitud); // 5
kude2将值1和2添加到Myzary数组的开头，结果返回阵列的新长度（5）。
splice (muta)
mâtodo splice（）允许在数组中添加，消除或替换元素。整个kouude3突变了原始数组，也就是说，它修改了它应用的阵列。
mâ©todo剪接（）进行三个或更多参数：
- 第一个参数指定将启动操作的数组中的位置。
- 第二个参数（可选）指定将从ãndice的位置消除的元素数量。
- 附加（可选）参数指定将从ZEE位置添加的元素。
const miArray = [1, 2, 3, 4, 5];
const elementosEliminados = miArray.splice(2, 2);
console.log(miArray); // [1, 2, 5]
console.log(elementosEliminados); // [3, 4]
在此示例中，splice用于消除从ãndix2的位置中消除两个元素。结果，消除了miarray阵列的元素3和4的元素3和4元素，并返回包含消除元素的数组。请注意，原始数组现在具有3个元素，表明它是由Mâtodo剪接修改的。
const miArray = [1, 2, 3, 4, 5];
miArray.splice(2, 0, 6, 7);
console.log(miArray); // [1, 2, 6, 7, 3, 4, 5]
在此示例中，kude3用于从ãndix2的位置添加元素6和7。结果，将元素6和7添加到myzarray阵列中，然后将随后的元素移至右侧。
。
const miArray = [1, 2, 3, 4, 5];
miArray.splice(2, 2, 6, 7);
console.log(miArray); // [1, 2, 6, 7, 5]
在上一个示例中，kude3用于用元素6和7的位置替换元素3和4。结果，元素3和4从数组miarray和元素6和7中取出。 。
slice (no muta)
整个slice（）允许在不修改原始数组的情况下创建一部分数组的副本。整个slice返回一个新矩阵，其中包括原始数组的选定元素。
此mâ©一切都需要两个可选的参数：
- 第一个参数指定了开始复制元素的位置。如果省略了此参数，则Slice（）将从数组的开头复制（ãndix0）。
- 第二个参数指定了完成元素副本的位置。如果省略了此参数，则Slice（）将复制直到数组结束。
让我们看一些示例
const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice();
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [1, 2, 3, 4, 5]
在上一个示例中，Kude4用于创建Array Miarray的完整副本。结果，创建了一个新矩阵，其中包含与原始数组相同的元素。
const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice(1, 4);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [2, 3, 4]
在此示例中，slice用于创建Miarray数组1和4 omers之间的元素的副本。结果，创建了一个新矩阵，其中包含元素2、3和4。
const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice(-3);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [3, 4, 5]
reduce (no muta)
世界减少用于迭代布置的元素，并通过还原函数积累最终值。还原功能需要两个参数：累加器和布置的当前值。
函数降低的基本语法如下：
array.reduce(function(acumulador, valorActual, index, arreglo) {
// código de la función reductora
}, valorInicial);
还原函数的参数如下：
-
kouude38：上一个迭代的累积值，或函数第二个参数中提供的初始值降低。
-
valorActual：当前迭代中布置的当前值。 -
kouude41：还原的原始布置。
index (opcional)：修复中的当前元素。
还原减少的第二个参数是累加器的初始值。如果没有提供此参数，则初始值将是安排的第一个元素，迭代将从第二个元素开始。
还原功能必须返回每个迭代中累加器的更新值。在以下迭代中，更新的累加器值将用作累加器。迭代完成后，累加器的最终值由于减少而返回。
例如，我们可以使用还原减少来添加数字排列的元素：
const numeros = [1, 2, 3, 4, 5];
const suma = numeros.reduce(function(acumulador, valorActual) {
return acumulador + valorActual;
}, 0);
console.log(suma); // salida: 15
在此示例中，累加器的初始值为0，还原函数将布置的当前值添加到每个迭代中的累加器。在迭代结束时，累加器的最终值为15，由于功能降低而返回。
sort (muta)
全部（）用于订购其位置的布置元素，也就是说，它修改了原始布置。
重要的是要考虑到所有不确定的元素在矩阵末尾订购。
sort（）函数的基本语法如下：
array.sort([comparador])
可选参数比较器是用于指定排序标准的回调函数。如果没有提供参数，则该安排的元素将被订购为字符的字符。如果提供了比较器，将用于比较布置的元素并确定其顺序。
lafunction³n比较器取自参数，这代表了正在比较的繁忙的元素。 lafunciã³ndebe返回一个负数si e -primer元素ES小于第二个，毫无用处。
例如，我们可以使用sort（）函数订购数字排列如下：
const numeros = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];
numeros.sort(function(a, b) {
return a - b;
});
console.log(numeros); // salida: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]
在此示例中，比较器函数减去第一个元素的第二个元素并返回结果。这以升序顺序订购了安排的要素。
我们还可以使用Sort（）函数根据特定属性订购对象的排列。例如：
const personas = [ { nombre: 'Ana', edad: 24 }, { nombre: 'Pedro', edad: 31 }, { nombre: 'Juan', edad: 18 }, { nombre: 'María', edad: 27 }, { nombre: 'Luis', edad: 22 },];
personas.sort(function(a, b) {
if (a.edad < b.edad) {
return -1;
}
if (a.edad > b.edad) {
return 1;
}
return 0;
});
console.log(personas); // salida: [
// { nombre: 'Juan', edad: 18 },
// { nombre: 'Luis', edad: 22 },
// { nombre: 'Ana', edad: 24 },
// { nombre: 'María', edad: 27 },
// { nombre: 'Pedro', edad: 31 }
// ]
在此示例中，比较器函数根据您的年龄进行比较对象，并根据相应顺序返回负，正或零数。
总而言之，JavaScript中的所有sord（）用于订购安排的元素。比较器函数指定了订单标准，并将两个元素作为参数，并根据相应的顺序返回负，正或零数。重要的是要突出显示Sort（）修改原始布置。
concat (no muta)
mãũtodoconcity（）它用于使一个人或负责当前安排并创建新的安排而不修改原始布置。
Concat（）函数的基本语法如下：
array.concat(valor1, valor2, ..., valorN)
din you value1，value2，...，value是与当前安排一致的一个或m不值。
Concat函数（）返回一种新的安排，其中包含当前安排的要素和过去安排的要素，作为在提供的顺序中作为参数。如果Concat的参数之一是一个安排，则该安排的要素分别添加到新的安排中。
例如，我们可以使用Concat函数（）来串联两个安排：
const numeros1 = [1, 2, 3];
const numeros2 = [4, 5, 6];
const numerosConcatenados = numeros1.concat(numeros2);
console.log(numerosConcatenados); // salida: [1, 2, 3, 4, 5, 6]
在此示例中，Concat（）函数用于将数字1和数字2在一个称为众多意识的新布置中加和数字2。
。我们还可以使用Concat（）函数将一个值或几个值与当前排列相连。例如：
const nombres = ['Ana', 'Pedro', 'Juan'];
const nombresConcatenados = nombres.concat('María', 'Luis');
console.log(nombresConcatenados); // salida: ['Ana', 'Pedro', 'Juan', 'María', 'Luis']
在此示例中，Concat（）函数用于将“Marãa”和“ Luis”值串联到一个名为“有意识名称的新布置”中。
重要的是要强调Concat（）函数不会修改原始布置，而是返回包含串联布置元素的新安排。
要考虑： concat复制新矩阵中原件的客观引用，以便原始矩阵和新矩阵都指的是同一对象。
因此，如果修改了对象，则可以看到新的和原始矩阵的更改。
flat (no muta)
mâ©all flat（）用于在一个维度上“平坦”一个多维安排。
平面函数（）的基本语法如下：
array.flat(depth)
深度是一个数字，指示必须扁平的最大深度。如果省略了深度参数，则假定为1的值，这意味着单个子rag级将被扁平。
flat function（）返回一种新的布置，其中包含原始布置的所有元素，但以单个级别的扁平化。
例如，我们可以使用flat（）函数来平移多维安排，如下所示：
const numeros = [1, 2, [3, 4, [5, 6]]];
const numerosAplanados = numeros.flat();
console.log(numerosAplanados); // salida: [1, 2, 3, 4, [5, 6]]
在此示例中，flat（）函数用于弄平数字排列，其中包含三个级别rag级。结果是一个称为数字的新安排，包含单个级别的原始布置的所有元素。
我们还可以使用具有深度参数的flat（）函数来在不同级别的深度上平坦的子rag。例如：
const numeros = [1, 2, [3, 4, [5, 6]]];
const numerosAplanados = numeros.flat(2);
console.log(numerosAplanados); // salida: [1, 2, 3, 4, 5, 6]
在此示例中，flat（）函数与2个深度参数一起使用，以使数字达到最多两个级别的深度。结果是一个称为数字的新安排，包含单个级别的原始布置的所有元素。
重要的是要强调Flat（）函数不会修改原始布置，而是返回包含扁平元素的新布置。如果原始布置的元素之一是一个对象，则Flat（）函数不会简单地将其包含在新的扁平布置中。
filter (no muta)
整个滤镜（）用于根据回调函数中指定的条件过滤布置的元素。回调函数必须返回一个布尔值，该值指示该元素是否必须包含在新的结果安排中。
过滤函数（）的基本语法如下：
array.filter(callback(element[, index[, array]])[, thisArg])
当回调是用于过滤布置元素的函数时，元素是正在评估的当前元素，索引是当前元素的ãndix，数组是原始布置。 thisarg参数是可选的，是指将在回调函数中使用的值。
filter函数（）返回一种新的安排，该安排仅包含通过回调函数证明的原始布置的元素。也就是说，如果回调函数返回true，则该元素将包含在新安排中，如果false返回，则将省略该元素。
例如，我们可以使用过滤器函数（）仅过滤偶数安排数：
const numeros = [1, 2, 3, 4, 5, 6];
const numerosPares = numeros.filter(function(num) {
return num % 2 === 0;
});
console.log(numerosPares); // salida: [2, 4, 6]
在此示例中，filter（）函数用于创建一个名为数字的新安排，该数字仅包含原始数字的偶数数字。回调函数使用操作员％检查当前号是否可除以2，如果是这样，则返回true，这意味着该数字必须包含在新安排中。
我们还可以根据多个标准使用带有复杂回调函数的Filter函数（）来过滤布置的元素。例如：
const personas = [
{ nombre: 'Juan', edad: 25 },
{ nombre: 'María', edad: 30 },
{ nombre: 'Pedro', edad: 20 }
];
const personasMayores = personas.filter(function(persona) {
return persona.edad > 25 && persona.nombre.startsWith('M');
});
console.log(personasMayores); // salida: [{ nombre: 'María', edad: 30 }]
在此示例中，Filter（）函数用于创建一个名为“人”的新安排，只有25年以上的人的名字以字母“ M”开头。回调函数使用每个对象的年龄和名称检查它是否符合指定条件。
重要的是要强调，filter（）函数不会修改原始布置，而是返回一个新的布置，该布置仅包含符合回调函数条件的元素。
join (no muta)
整个join（）用于将单个文本链中一个布置的所有元素串联。整个join（）接收一个可选的参数，该参数指定将用于将每个元素分为结果链的分离器。
JOIN（）函数的基本语法如下：
array.join([separator])
分离器是分离器，将用于分离结果链中的每个元素。如果未提供此参数，则将使用逗号（“”）作为默认分离器。
整个join（）返回一条包含由指定分离器分隔的布置的元素。
例如，我们可以使用join（）函数来串联单个链中的布置元素：
const palabras = ['hola', 'mundo', 'feliz', 'día'];
const frase = palabras.join('-');
console.log(frase); // salida: "hola-mundo-feliz-día"
在此示例中，join（）函数用于在单个链中以脚本分离的单个链中的单词排列的元素进行连接。结果分配给短语变量。
我们还可以使用join（）函数从对象布置创建链。在这种情况下，我们必须提供一个回调函数，以将每个对象与其他元素串联之前，将每个对象转换为链。例如：
const personas = [
{ nombre: 'Juan', edad: 25 },
{ nombre: 'María', edad: 30 },
{ nombre: 'Pedro', edad: 20 }
];
const lista = personas.map(function(persona) {
return persona.nombre + ' (' + persona.edad + ' años)';
}).join(', ');
console.log(lista); // salida: "Juan (25 años), María (30 años), Pedro (20 años)"
在此示例中，Map（）函数用于创建一个新的布置，该安排包含一个安排中每个对象的链条。回调功能使用每个对象的名称和年龄来构建链条。然后，使用join（）函数将单个列表中的所有链条串联为逗号分隔的单个列表。
整个join（）不修改原始布置，而是返回一个包含串联布置的所有元素的新链。
map (no muta)
在数组类型对象中使用map（）map（）map（）从现有布置中创建新的布置。通过将转换函数应用于原始布置的每个元素来创建新的结果。换句话说，整个地图（）iTera在安排的元素上，并返回新的安排，并将函数应用于每个元素的结果。
地图（）的基本语法如下：
array.map(function(currentValue, index, arr) {
// Código que se ejecuta para cada elemento del arreglo
return newValue;
});
如果数组是原始布置，则CurrentValue是正在处理的当前元素的值，索引是安排中当前元素的ãndix，而RART是完整的原始布置。作为参数作为条目传递的转换函数是安排的当前元素，并返回转换的结果。
例如，假设我们有一个数字安排，我们想创建一个新的安排，其中每个数字乘以两个。我们可以使用整个Map（）来实现这一点：
const numeros = [1, 2, 3, 4, 5];
const numerosDobles = numeros.map(function(numero) {
return numero * 2;
});
console.log(numerosDobles); // salida: [2, 4, 6, 8, 10]
在此示例中，转换函数将每个原始布置的每个数量乘以两个。结果存储在称为NumeroSdobles的新布置中。
整个地图（）也可以用于转换对象布置。在这种情况下，转换函数必须返回具有转换属性的对象，我们要在新安排中包含的对象。例如，假设我们有一个代表人的对象的安排，我们想创建一个仅包含这些人名称的新安排：
const personas = [
{ nombre: 'Juan', edad: 25 },
{ nombre: 'María', edad: 30 },
{ nombre: 'Pedro', edad: 20 }
];
const nombres = personas.map(function(persona) {
return persona.nombre;
});
console.log(nombres); // salida: ['Juan', 'María', 'Pedro']
在此示例中，转换函数返回原始布置中每个对象的属性名称。结果存储在称为名称的新布置中。
重要的是要强调Map（）不会修改原始布置，而是返回带有转换结果的新安排。新安排的长度将与原始布置相同。
find (no muta)
JavaScript中的整个find（）是数组类型对象中使用的函数，以在布置中查找特定元素。世界返回首先元素，该元素符合测试功能中指定的条件。如果找不到符合这种情况的元素，那么世界将返回不确定的。
mârd的基本语法全部find（）如下：
array.find(function(currentValue, index, arr) {
// Código que se ejecuta para cada elemento del arreglo
return condition;
});
如果数组是原始布置，则CurrentValue是正在处理的当前元素的值，索引是安排中当前元素的ãndix，而RART是完整的原始布置。作为参数作为条目传递的测试功能是安排的当前元素
例如，假设我们有一个代表人的物体的安排，并希望寻找第一个年龄超过25岁的人。我们可以使用整个Find（）来实现这一点：
const personas = [
{ nombre: 'Juan', edad: 25 },
{ nombre: 'María', edad: 30 },
{ nombre: 'Pedro', edad: 20 }
];
const personaMayor25 = personas.find(function(persona) {
return persona.edad > 25;
});
console.log(personaMayor25); // salida: { nombre: 'María', edad: 30 }
在此示例中，测试功能评估当前人员的年龄是否大于25岁。整个find（）返回符合此条件的布置的第一个元素，在这种情况下，这是代表Marãa的对象。
整个find（）也可以用于在简单值的排列中搜索元素。在这种情况下，测试功能必须评估当前值是否等于我们要寻找的值。例如，假设我们有一个数字的安排，我们想寻找第3：
的第一个数字
const numeros = [1, 4, 7, 9, 12, 15];
const numeroDivisible3 = numeros.find(function(numero) {
return numero % 3 === 0;
});
console.log(numeroDivisible3); // salida: 9
在此示例中，测试函数使用操作员％评估当前数是否可除以3。整个find（）返回符合此情况的安排的第一个元素，在这种情况下是数字9。
重要的是要强调整个Find（）仅返回符合BagSqueda条件的第一个元素。如果有几个元素符合条件，则仅返回第一个元素。如果需要符合条件的所有元素，则应使用整个过滤器（）。
filter (no muta)
整个过滤器（）在数组对象中用于过滤符合指定条件的元素，并返回带有符合所述条件的元素的新安排。整个过滤器（）的基本语法如下：
array.filter(function(currentValue, index, arr) {
// Código que se ejecuta para cada elemento del arreglo
return condition;
});
如果数组是原始布置，则CurrentValue是正在处理的当前元素的值，索引是安排中当前元素的ãndix，而RART是完整的原始布置。作为参数作为条目传递的测试功能是安排的当前元素
例如，假设我们有一个数字的布置，我们只想过滤是对的数字。我们可以使用整个Filter（）来实现以下操作：
const numeros = [1, 2, 3, 4, 5, 6];
const numerosPares = numeros.filter(function(numero) {
return numero % 2 === 0;
});
console.log(numerosPares); // salida: [2, 4, 6]
在此示例中，测试函数评估当前号是否甚至使用运算符％。整个滤镜（）返回一个新的布置，其原始布置的元素符合此条件，在这种情况下，这是偶数数字。
整个过滤器（）也可以用于过滤对象布置的元素。在这种情况下，测试功能必须评估对象的任何特性是否符合BãºSqueda的状况。例如，假设我们有代表人的物体的安排，我们只想过滤合法年龄的人：
const personas = [
{ nombre: 'Juan', edad: 25 },
{ nombre: 'María', edad: 30 },
{ nombre: 'Pedro', edad: 17 }
];
const personasMayoresEdad = personas.filter(function(persona) {
return persona.edad >= 18;
});
console.log(personasMayoresEdad); // salida: [{ nombre: 'Juan', edad: 25 }, { nombre: 'María', edad: 30 }]
在此示例中，测试函数评估当前人员的年龄是否大于或等于18岁。整个过滤器（）返回一个新的安排，其原始安排的对象符合此条件，在这种情况下，这是法定年龄的人。
重要的是要强调整个滤镜（）返回一个新的布置，其元素符合BãºSqueda的状况。原始布置未修改。如果需要修改原始安排，则应使用所有MAP（）。
includes (no muta)
JavaScript中的全部Include（）是数组对象中使用的函数，以确定在布置中是否有特定值。整体的基本语法包括（）如下：
array.includes(valueToFind[, fromIndex])
如果阵列是制作bx squeda的排列，则valuetofind是在布置中寻求的值，而从索引则是一个可选的zende，该Zende指示从中开始BéºSqueda。
mâ©ally Incluber（）返回一个布尔值，该值指示指定值是否在安排中。如果该值在安排中，则将返回真实；否则，返回false。
例如，假设我们有一个名称的安排，我们想确定是否在布置中是一个特定的名称。我们可以使用整体包含（）来实现这一点：
const nombres = ['Juan', 'María', 'Pedro'];
const estaJuan = nombres.includes('Juan');
const estaLuis = nombres.includes('Luis');
console.log(estaJuan); // salida: true
console.log(estaLuis); // salida: false
在此示例中，所有Inclact（）用于确定名称“ Juan”是否在布置中。 Mâ©所有内容都返回真实，表明名称在布置中。然后，使用Mâ©来确定名称“ Luis”是否在布置中。 Mâ©everyther返回错误，表明名称不在安排中。
我们还可以使用第二个可选的索引来指示从中启动basqueda的。例如：
const numeros = [1, 2, 3, 4, 5];
const estaCinco = numeros.includes(5, 3);
console.log(estaCinco); // salida: true
在此示例中，全部include（）用于确定值5是否在排列中。
重要的是要强调整个包含（）执行一个严格的海湾，即使用严格的平等操作员（===）比较值。这意味着值必须具有相同的类型并且具有相同的值，以使一切返回true。例如，如果我们在安排中寻找2号
indexof (no muta)
JavaScript中的整个indexof（）用于在安排中寻求指定元素的位置。整个索引（）的基本语法如下：
array.indexOf(searchElement[, fromIndex])
如果阵列是进行bx squeda的排列，则搜索是在布置中寻求的元素，而索引是一个可选的zende，它指示从那里开始b bundix。
mâ©all indexof（）返回 first 元素的ãndix，该元素与指定值或-1相匹配，如果值不在安排中。
例如，假设我们有一个数字的安排，我们想确定数字3在安排中的位置。我们可以使用整个索引（）来实现以下操作：
const numeros = [1, 2, 3, 4, 5];
const posicionTres = numeros.indexOf(3);
console.log(posicionTres); // salida: 2
在此示例中，所有indexof（）用于确定数字中数字3的位置。 mé一切返回2，这是与指定值重合的第一个元素的非迪克斯。
我们还可以使用第二个可选的索引来指示从中启动basqueda的。例如：
const numeros = [1, 2, 3, 4, 5];
const posicionCuatro = numeros.indexOf(4, 2);
console.log(posicionCuatro); // salida: 3
在此示例中，所有indexof（）用于确定从ãndix2开始的数字中的数字4的位置。世界返回3，这是与指定值重合的第一个元素的igice从2.
some
使用JavaScript中的整个sub（）用于验证布置的至少元素是否符合特定条件。整个subm（）的基本语法如下：
array.some(callback[, thisArg])
在进行检查的排列中，回调是在“安排p”的每个元素中执行的函数
呼叫返回功能。该函数在布置中的每个元素执行一次，直到元素返回true。如果函数为至少一个安排元素返回
例如，假设我们有一个数字安排，我们想检查至少一个元素大于10
const numeros = [1, 2, 15, 4, 5];
const alMenosUnoMayorQueDiez = numeros.some((numero) => {
return numero > 10;
});
console.log(alMenosUnoMayorQueDiez); // salida: true
在此示例中，整个sub（）用于检查bessectmén的数量是否至少一个sub（）返回true。
forEach
JavaScript中的所有foreach（）用于迭代安排的元素，并为每个元素执行一个函数。 mâmâforeach（）的基本语法如下：
array.forEach(callback[, thisArg])
而当数组是它的安排时，回调是每个元素执行的函数，而thisarg是可选值，在呼叫返回函数的呼叫函数中用作此用作。
呼叫返回功能。该函数最多可以具有三个参数：当前元素的值，当前元素的当前和它的布置。
例如，假设我们有一个数字安排，我们想在控制台中打印每个数字。我们可以使用世界（）来实现这一目标：
const numeros = [1, 2, 3, 4, 5];
numeros.forEach((numero) => {
console.log(numero);
});
在此示例中，整个foreach（）用于迭代数字并执行呼吁安排的每个元素的功能。呼叫返回功能只需在控制台中打印每个号码。