数组(Array)#

`Array`.`append()`#

描述: 向数组末尾添加新元素。类似于 push()，但返回修改后的数组。可以考虑使用展开语法（参见示例）。

语法: Array.append(elem1, elem2?, ..., elemN?)

返回值：数组

来源: 自定义 n8n 功能

参数：

elem1（any）- 要附加的第一个元素
elem2（any）- 可选 - 要附加的第二个元素
elemN（any）- 可选 - 要追加的第N个元素

示例：

// arr = ['forget', 'me']
arr.append('not') //=> arr = ['forget', 'me', 'not']

// arr = [9, 0, 2]
arr.append(1, 0) //=> [9, 0, 2, 1, 0]

// Consider using spread syntax instead
[...arr, 1, 0]  //=> [9, 0, 2, 1, 0]

`Array`.`average()`#

描述: 返回数组中数字的平均值。如果存在任何非数字项，则抛出错误。

语法: Array.average()

返回值： 数字

来源: 自定义 n8n 功能

示例：

// arr = [12, 1, 5]
arr.average() //=> 6

`Array`.`chunk()`#

描述： 将数组拆分为多个子数组，每个子数组具有指定的长度

语法： Array.chunk(长度)

返回值：数组

来源: 自定义 n8n 功能

参数：

length（数字）- 每个块中的元素数量

示例：

// arr = [1, 2, 3, 4, 5, 6]
arr.chunk(2) //=> [ [1,2], [3,4], [5,6] ]

`Array`.`compact()`#

描述： 从数组中移除所有空值。null、"" 和 undefined 都算作空值。

语法: Array.compact()

返回值：数组

来源: 自定义 n8n 功能

示例：

// arr = [2, null, 1, ""]
arr.compact() //=> [2, 1]

`Array`.`concat()`#

描述: 将一个或多个数组连接到基础数组的末尾

语法: Array.concat(array2, array3?, ... arrayN?)

返回值：数组

来源： JavaScript 函数

参数：

array2（数组）- 要在基础数组末尾连接的第一个数组
array3（数组）- 可选 - 要连接到基础数组末尾的第二个数组
arrayN（数组）- 可选 - 要连接到基础数组末尾的第 N 个数组

示例：

// arr1 = ['Nathan', 'Jan']
arr1.concat(['Steve', 'Bill']) // ['Nathan', 'Jan', 'Steve', 'Bill']

// arr1 = [5, 4]
// arr2 = [100, 101]
// arr3 = ['a', 'b']
arr1.concat(arr2, arr3) // [5, 4, 100, 101, 'a', 'b']

`Array`.`difference()`#

描述: 比较两个数组。返回基础数组中所有不在otherArray中的元素。

语法: Array.difference(otherArray)

返回值：数组

来源: 自定义 n8n 功能

参数：

otherArray（数组）- 要与基础数组比较的数组

示例：

// arr = [1, 2, 3]
arr.difference([2, 3]) //=> [1]

`Array`.`filter()`#

描述: 返回一个只包含满足条件的元素的数组。条件是一个返回true或false的函数。

语法: Array.filter(function(element, index?, array?), thisValue?)

返回值：数组

来源： JavaScript 函数

参数：

function()（function）- 对每个数组元素运行的函数。如果它返回true，该元素将被保留。可以考虑使用箭头函数表示法以节省空间。
element（any）- 当前元素的值
index（数字）- 可选 - 当前元素在数组中的位置（从 0 开始）
array（数组）- 可选 - 正在处理的数组。很少需要。
thisValue（any）- 可选 - 作为函数的 this 值传递的一个值。很少需要。

示例：

// Keep ages over 18 (using arrow function notation):
// ages = [12, 33, 16, 40]
ages.filter(age => (age > 18)) //=> [33, 40]

// Keep names under 5 letters long (using arrow function notation):
// names = ['Nathan', 'Bob', 'Sebastian']
ages.filter(age => (age.length < 5)) //=> ["Bob"]

// Or using traditional function notation:
ages.filter(function(age){return age.length < 5}) //=> ["Bob"]

// Keep numbers at odd indexes
// nums = [1, 7, 3, 10, 5]
ages.filter((num, index) => {return index%2 != 0}) //=> [7, 10]

`Array`.`find()`#

描述: 返回数组中满足提供条件的第一个元素。条件是一个返回true或false的函数。如果未找到匹配项，则返回undefined。

如果你需要所有匹配的元素，使用 filter()。

语法: Array.find(function(element, index?, array?), thisValue?)

返回值： 任意

来源： JavaScript 函数

参数：

function()（function）- 对每个数组元素运行的函数。一旦它返回 true，该元素将被返回。考虑使用箭头函数表示法以节省空间。
element（any）- 当前元素的值
index（数字）- 可选 - 当前元素在数组中的位置（从 0 开始）
array（数组）- 可选 - 当前元素的数组。很少需要。
thisValue（any）- 可选 - 作为函数的 this 值传递的一个值。很少需要。

示例：

// Find first age over 18 (using arrow function notation):
// ages = [12, 33, 16, 40]
ages.find(age => (age > 18)) //=> 33

// Find first name under 5 letters long (using arrow function notation):
// names = ['Nathan', 'Bob', 'Sebastian']
ages.find(age => (age.length < 5)) //=> 'Bob'

// Or using traditional function notation:
ages.find(function(age){return age.length < 5}) //=> 'Bob'

`Array`.`first()`#

描述: 返回数组的第一个元素

语法: Array.first()

返回值： 任意

来源: 自定义 n8n 功能

示例：

// arr = ['quick', 'brown', 'fox']
arr.first() //=> 'quick'

`Array`.`includes()`#

描述: 如果数组包含指定的元素，返回 true

语法： Array.includes(元素, 起始位置?)

返回值： 布尔类型

来源： JavaScript 函数

参数：

element（any）- 要在数组中查找的值
start（数字）- 可选 - 开始查找的索引

示例：

// names = ["Bob", "Bill", "Nat"];
names.includes("Nat") //=> true
names.includes("Nathan") //=> false

`Array`.`indexOf()`#

描述： 返回数组中第一个匹配元素的位置，如果未找到该元素则返回 -1。位置从 0 开始。

语法: Array.indexOf(元素, 起始位置?)

返回值： 数字

来源： JavaScript 函数

参数：

element（any）- 要查找的值
start（数字）- 可选 - 开始查找的索引

示例：

// names = ["Bob", "Bill", "Nat"];
names.indexOf("Nat") //=> 2

// names = ["Bob", "Bill", "Nat"];
names.indexOf("Nathan") //=> -1

`Array`.`intersection()`#

描述: 比较两个数组。返回基础数组中也存在于另一个数组的所有元素。

语法: Array.intersection(otherArray)

返回值：数组

来源: 自定义 n8n 功能

参数：

otherArray（数组）- 要与基础数组比较的数组

示例：

// arr = [1, 2]
arr.intersection([2, 3]) //=> [2]

`Array`.`isEmpty()`#

描述: 如果数组没有元素或为 null，则返回 true

语法： Array.isEmpty()

返回值： 布尔类型

来源: 自定义 n8n 功能

示例：

// arr = []
arr.isEmpty() //=> true

// arr = ['quick', 'brown', 'fox']
arr.isEmpty() //=> false

`Array`.`isNotEmpty()`#

描述： 如果数组至少有一个元素，则返回 true

语法: Array.isNotEmpty()

返回值： 布尔类型

来源: 自定义 n8n 功能

示例：

// arr = ['quick', 'brown', 'fox']
arr.isNotEmpty() //=> true

// arr = []
arr.isNotEmpty() //=> false

`Array`.`join()`#

描述： 将数组的所有元素合并成一个字符串，并可在每个元素之间添加可选的分隔符。

split() 的相反操作。

语法： Array.join(分隔符?)

返回值： 字符串

来源： JavaScript 函数

参数：

separator（字符串）- 可选 - 每个元素之间要插入的字符

示例：

// arr = ['Wind', 'Water', 'Fire']
a.join(" + ") //=> 'Wind + Water + Fire'

// arr = ['Wind', 'Water', 'Fire']
a.join() //=> 'Wind,Water,Fire'
a.join("") //=> 'WindWaterFire'

`Array`.`last()`#

描述: 返回数组的最后一个元素

语法: Array.last()

返回值： 任意

来源: 自定义 n8n 功能

示例：

// arr = ['quick', 'brown', 'fox']
arr.last() //=> 'fox'

`Array`.`length`#

描述: 数组中的元素数量

语法: Array.length

返回值： 数字

来源： JavaScript 函数

示例：

// names = ["Bob", "Bill", "Nat"];
names.length //=> 3

`Array`.`map()`#

描述：通过对原数组的每个元素应用一个函数来创建一个新数组

语法: Array.map(function(element, index?, array?), thisValue?)

返回值：数组

来源： JavaScript 函数

参数：

function()（function）- 对每个数组元素运行的函数。在新数组中，该函数的输出将取代元素。可以考虑使用箭头函数表示法来节省空间。
element（any）- 当前元素的值
index（数字）- 可选 - 当前元素在数组中的位置（从 0 开始）
array（数组）- 可选 - 当前元素的数组。很少需要。
thisValue（any）- 可选 - 作为函数的 this 值传递的一个值。很少需要。

示例：

// Double all numbers (using arrow function notation):
// nums = [12, 33, 16]
nums.map(num => num*2) //=> [24, 66, 32]

// Convert elements to uppercase (using arrow function notation):
// words = ['hello', 'old', 'chap']
words.map(word => word.toUpperCase()) //=> ['HELLO', 'OLD', 'CHAP']]

// Or using traditional function notation:
words.map(function(word){return word.toUpperCase()}) //=> ['HELLO', 'OLD', 'CHAP']]

`Array`.`max()`#

描述: 返回数组中的最大数字。如果存在任何非数字值，则抛出错误。

语法: Array.max()

返回值： 数字

来源: 自定义 n8n 功能

示例：

// arr = [1, 12, 5]
arr.max() //=> 12

`Array`.`min()`#

描述： 返回数组中最小的数字。如果存在非数字元素，则抛出错误。

语法: Array.min()

返回值： 数字

来源: 自定义 n8n 功能

示例：

// arr = [12, 1, 5]
arr.min() //=> 1

`Array`.`pluck()`#

描述: 返回一个数组，其中包含数组中每个对象中给定字段的值。会忽略任何不是对象或没有与提供的字段名匹配的键的数组元素。

语法: Array.pluck(fieldName1?, fieldName2?, …)

返回值：数组

来源: 自定义 n8n 功能

参数：

fieldName1（字符串）- 可选 - 用于检索值的第一个键
fieldName2（字符串）- 可选 - 用于检索值的第二个键

示例：

// arr = [{'name':'Nathan','age':42},{'name':'Jan','city':'Berlin'}]
arr.pluck('name') //=> ["Nathan", "Jan"]

// arr = [{'name':'Nathan','age':42},{'name':'Jan','city':'Berlin'}]
arr.pluck('age') //=> [42]

`Array`.`randomItem()`#

描述： 从数组中返回一个随机选择的元素

语法： Array.randomItem()

返回值： 任意

来源: 自定义 n8n 功能

示例：

// arr = ['quick', 'brown', 'fox']
arr.randomItem() //=> 'brown'
arr.randomItem() //=> 'quick'

`Array`.`reduce()`#

描述: 通过对每个元素应用一个函数，将数组缩减为单个值。该函数将当前元素与先前元素的缩减结果结合，产生一个新的结果。

语法: Array.reduce(function(prevResult, currentElem, currentIndex?, array?), initResult)

来源： JavaScript 函数

参数：

function()（function）- 一个函数用于对每个数组元素执行操作。接收累积的结果和当前元素，并返回一个新的累积结果。考虑使用箭头函数表示法来节省空间。
prevResult（any）- 将函数应用于前一个元素所得到的累积结果。在处理第一个元素时，它被设置为 initResult（如果未指定，则为数组的第一个元素）。
currentElem（any）- 当前正在处理的数组中的值
currentIndex（数字）- 可选 - 当前元素在数组中的位置（从 0 开始）
array（数组）- 可选 - 正在处理的数组。很少需要。
initResult（any）- 可选 - prevResult 的初始值，在第一次对数组元素调用函数时使用。如果未指定，它将被设置为第一个数组元素，并且第一次函数调用将针对第二个数组元素，而不是第一个。

示例：

// Sum numbers (using arrow function notation):
// nums = [12, 33, 16]
nums.reduce((result, num) => (result+num), 0) //=> 61

// Join letters and uppercase (using arrow function notation):
// chars = ['a', 'b', 'c']
chars.reduce((result, char) => (result+char.toUpperCase()), '') //=> 'ABC'

// Or using traditional function notation:
chars.reduce(function(result, char){return result+char.toUpperCase()}, '') //=> 'ABC'

`Array`.`removeDuplicates()`#

描述： 从数组中移除任何重复出现的元素

语法: Array.removeDuplicates(keys?)

返回值：数组

来源: 自定义 n8n 功能

参数：

keys（字符串）- 可选 - 用于对象数组。一个键，或以逗号分隔的键列表，用于限制检查。如果省略，则检查所有键。

示例：

// arr = ['quick', 'brown', 'quick']
arr.removeDuplicates() //=> ['quick', 'brown']

`Array`.`renameKeys()`#

描述: 更改数组中所有对象的匹配键（字段名）。通过添加额外的参数重命名多个键，即 from1, to1, from2, to2, ...。

语法: Array.renameKeys(from, to)

返回值：数组

来源: 自定义 n8n 功能

参数：

from（字符串）- 重命名的关键
to（字符串）- 新键名

示例：

// arr = [{'name':'bob'},{'name':'meg'}]
arr.renameKeys('name', 'x') //=> [{"x": "bob"},{"x": "meg"}]]

`Array`.`reverse()`#

描述: 将数组中元素的顺序反转

语法: Array.reverse()

返回值：数组

来源： JavaScript 函数

示例：

// arr = ['dog', 'bites', 'man']
arr.reverse() //=> ['man', 'bites', 'dog']

`Array`.`slice()`#

描述： 返回数组的一部分，从 start 索引开始，到 end 索引结束（不包括 end 索引）。索引从 0 开始。

语法： Array.slice(start, end)

返回值：数组

来源： JavaScript 函数

参数：

start（数字）- 可选 - 开始的位置。位置从0开始。负数从数组末尾向前计数。
end（数字）- 可选 - 要选择到的位置。结束位置的元素不包括在内。负数表示从数组末尾开始选择。如果省略，将提取到数组的末尾。

示例：

// arr = [1, 2, 3, 4, 5]
arr.slice(2, 4) //=> [3, 4]

// arr = [1, 2, 3, 4, 5]
arr.slice(2) //=> [3, 4, 5]

// arr = [1, 2, 3, 4, 5]
arr.slice(-2) //=> [4, 5]

`Array`.`smartJoin()`#

描述: 从对象数组创建一个单一对象。数组中的每个对象为返回的对象提供一个字段。数组中的每个对象必须包含一个带有键名称的字段和一个带有值的字段。

语法: Array.smartJoin(keyField, nameField)

返回值：对象

来源: 自定义 n8n 功能

参数：

keyField（字符串）- 每个对象中包含键名的字段
nameField（字符串）- 每个对象中包含该值的字段

示例：

// arr => [{'field':'age','value':2},{'field':'city','value':'Berlin'}]
arr.smartJoin('field','value') //=> {"age": 2, "city": "Berlin"}

`Array`.`sort()`#

描述： 重新排序数组的元素。对于按字母顺序排序字符串，不需要参数。对于排序数字或对象，请参见示例。

语法: Array.sort(compareFunction(a, b)?)

返回值：数组

来源： JavaScript 函数

参数：

compareFunction（函数）- 可选 - 一个用于比较两个数组元素并返回一个数字以指示哪个元素排在前面的函数： 返回 < 0：a 排在 b 前面 返回 0：a 和 b 相等（保持顺序不变） 返回 > 0：b 排在 a 前面

如果未指定函数，则将所有值转换为字符串并比较它们的字符编码。

🌐 If no function is specified, converts all values to strings and compares their character codes.

a（any）- 函数中要比较的第一个元素
b（any）- 函数中要比较的第二个元素

示例：

// No need for a param when sorting strings
// arr = ['d', 'a', 'c', 'b']
arr.sort() //=> ['a', 'b', 'c', 'd']

// To sort numbers, you must use a function
// arr = [4, 2, 1, 3]
arr.sort((a, b) => (a - b)) //=> [1, 2, 3, 4]

// Or using traditional function notation:
arr.sort(function(a, b){return a - b}) //=> [1, 2, 3, 4]

// Sort in reverse alphabetical order
// arr = ['d', 'a', 'c', 'b']
arr.sort((a, b) => b.localeCompare(a)) //=> ['d', 'c', 'b', 'a']

// Sort array of objects by a property
// arr = [{name:'Zak'}, {name:'Abe'}, {name:'Bob'}]
arr.sort((a, b) => a.name.localeCompare(b.name)) //=> [{name:'Abe'}, {name:'Bob'}, {name:'Zak'}]

`Array`.`sum()`#

描述： 返回数组中所有数字的总和。如果存在任何非数字，则会抛出错误。

语法： Array.sum()

返回值： 数字

来源: 自定义 n8n 功能

示例：

// arr = [12, 1, 5]
arr.sum() //=> 18

`Array`.`toJsonString()`#

描述： 将数组转换为 JSON 字符串。与 JavaScript 的 JSON.stringify() 相同。

语法: Array.toJsonString()

返回值： 字符串

来源: 自定义 n8n 功能

示例：

// obj = ['quick', 'brown', 'fox']
obj.toJsonString() //=> '["quick","brown","fox"]'

`Array`.`toSpliced()`#

描述: 在指定位置添加和/或移除数组元素。

另请参见 slice() 和 append()。

语法: Array.toSpliced(start, deleteCount, elem1, ....., elemN)

返回值：数组

来源： JavaScript 函数

参数：

start（数字）- 要添加或删除元素的索引（位置）。新元素将插入到该索引处元素的前面。负索引从数组的末尾开始计数。
deleteCount（数字）- 可选 - 要删除的元素数量。如果省略，则从 start 索引开始删除所有元素。
elem1（any）- 可选 - 要添加的第一个新元素
elem2（any）- 可选 - 第二个要添加的新元素
elemN（any）- 可选 - 要添加的第 N 个新元素

示例：

// Insert element at index 1
// months = ['Jan', 'Mar']
months.toSpliced(1, 0, "Feb") // ['Jan', 'Feb', 'Mar']

// Delete 2 elements starting at index 1
// arr = ["don't", "make", "me", "do", "this"]
arr.toSpliced(1, 2) // ["don't", "do", "this"]

// Replace 2 elements starting at index 1
// arr = ["don't", "be", "evil"]
arr.toSpliced(1, 2, 'eat', 'slugs') // ["don't", "eat", "slugs"]

`Array`.`toString()`#

描述: 将数组转换为字符串，值之间用逗号分隔。要使用不同的分隔符，请改用 join()。

语法： Array.toString()

返回值： 字符串

来源： JavaScript 函数

示例：

// words = ['make', 'my', 'day']
words.toString() //=> 'make,my,day'

`Array`.`union()`#

描述： 将两个数组连接起来，然后移除任何重复项

语法: Array.union(otherArray)

返回值：数组

来源: 自定义 n8n 功能

参数：

otherArray（数组）- 要与基础数组合并的数组

示例：

// arr = [1, 2]
arr.union([2, 3]) //=> [1, 2, 3]

`Array`.`unique()`#

描述: 从数组中删除所有重复的元素

语法: Array.unique()

返回值：数组

来源: 自定义 n8n 功能

示例：

// arr = ['quick', 'brown', 'quick']
arr.unique() //=> ['quick', 'brown']

数组(Array)#

Array.append()#

Array.average()#

Array.chunk()#

Array.compact()#

Array.concat()#

Array.difference()#

Array.filter()#

Array.find()#

Array.first()#

Array.includes()#

Array.indexOf()#

Array.intersection()#

Array.isEmpty()#

Array.isNotEmpty()#

Array.join()#

Array.last()#

Array.length#

Array.map()#

Array.max()#

Array.min()#

Array.pluck()#

Array.randomItem()#

Array.reduce()#

Array.removeDuplicates()#

Array.renameKeys()#

Array.reverse()#

Array.slice()#

Array.smartJoin()#

Array.sort()#

Array.sum()#

Array.toJsonString()#

Array.toSpliced()#

Array.toString()#

Array.union()#

Array.unique()#

`Array`.`append()`#

`Array`.`average()`#

`Array`.`chunk()`#

`Array`.`compact()`#

`Array`.`concat()`#

`Array`.`difference()`#

`Array`.`filter()`#

`Array`.`find()`#

`Array`.`first()`#

`Array`.`includes()`#

`Array`.`indexOf()`#

`Array`.`intersection()`#

`Array`.`isEmpty()`#

`Array`.`isNotEmpty()`#

`Array`.`join()`#

`Array`.`last()`#

`Array`.`length`#

`Array`.`map()`#

`Array`.`max()`#

`Array`.`min()`#

`Array`.`pluck()`#

`Array`.`randomItem()`#

`Array`.`reduce()`#

`Array`.`removeDuplicates()`#

`Array`.`renameKeys()`#

`Array`.`reverse()`#

`Array`.`slice()`#

`Array`.`smartJoin()`#

`Array`.`sort()`#

`Array`.`sum()`#

`Array`.`toJsonString()`#

`Array`.`toSpliced()`#

`Array`.`toString()`#

`Array`.`union()`#

`Array`.`unique()`#