管理员在同步第三方数据源时，需要配置员工同步映射策略，映射策略分为字段映射和表达式映射两种，本文将介绍这两种映射策略，并重点介绍表达式映射策略如何配置。

管理员在管理后台的身份 > 账号配置 > 数据源同步功能页添加数据源时，需要配置第三方数据源和飞连内字段的映射关系，用于企业自主指定选择需要同步的数据。

配置时映射规则支持字段映射和表达式映射，介绍如下：

本章节汇总表达式支持的语法，您可以参考并编辑实际所需的表达式。

字面量 #

字面量（Literals）用于表示固定值，表达式语法中支持的字面量如下表所示。

运算符 #

表达式中支持的运算符说明如下表所示。

1..3 == [1, 2, 3]

array[1:3] == [2, 3]
array[1:-1] == [2, 3, 4]
array[:3] == [1, 2, 3]
array[3:] == [4, 5]
array[:] == array

// 1. 将 user.Name 字段值传入 lower 函数。
// 2. 转换为全小写后，传入 split 函数，以空格为分隔符，拆分字符串。
user.Name

变量 #

表达式内可以使用 let 关键字声明变量，声明后可在当前表达式内使用变量。变量名必须以字母或者下划线（）开头，变量名可以包含字母、数字或下划线（）。例如：

let x = 42; x * 2

多个变量可以通过分号分隔。例如：

let x = 42; 
let y = 2; 
x * y

变量值可以是表达式，以配置管道运算符（|）为例，结合变量构建的表达式如下：

let name = user.Name | lower() | split(" "); 
"Hello, " + name[0] + "!"

谓语 #

filter（过滤）, all（所有）, any（任一）, one（一个）, none（无）等谓语可应用于表达式中。例如以下示例，创建一个 0 到 9 的数组，然后通过偶数判断来过滤该数组。

filter(0..9, {# % 2 == 0})

如果数组的项是 struct（结构体） 或者 map（映射），可以省略#访问字段。例如， *.Value可以写为.Value。

filter(tweets, {len(.Content) > 240})

其中大括号{}可以省略：

filter(tweets, len(.Content) > 240)

字符串函数 #

trim(str[,chars]) #

从字符串str的两端删除空格。chars参数为可选参数，用于设置要删除的字符集合。

trim("  Hello  ") == "Hello" // 删除空格
trim("__Hello__", "_") == "Hello" // 删除下划线（_）

trimPrefix(str, prefix) #

如果字符串str以指定的前缀prefix开头，则删除该前缀。

trimPrefix("HelloWorld", "Hello") == "World" // 删除 Hello 前缀

trimSuffix(str, suffix) #

如果字符串str以指定的后缀suffix结尾，则删除该后缀。

trimSuffix("HelloWorld", "World") == "Hello" // 删除 World 后缀

upper(str) #

将字符串str中的所有字符转换为大写。

upper("hello") == "HELLO"

lower(str) #

将字符串str中的所有字符转换为小写。

lower("HELLO") == "hello"

split(str, delimiter[, n]) #

在每个分隔符delimiter处拆分字符串str，并返回子字符串的数组。

split("apple,orange,grape", ",") == ["apple", "orange", "grape"]
split("apple,orange,grape", ",", 2) == ["apple", "orange,grape"]

splitAfter(str, delimiter[, n]) #

在每个分隔符delimiter之后拆分字符串str。

splitAfter("apple,orange,grape", ",") == ["apple,", "orange,", "grape"]
splitAfter("apple,orange,grape", ",", 2) == ["apple,", "orange,grape"]

replace(str, old, new) #

将字符串str中的所有old替换为new。

replace("Hello World", "World", "Universe") == "Hello Universe"

repeat(str, n) #

将字符串str重复n次。

repeat("Hi", 3) == "HiHiHi"

indexOf(str, substring) #

返回字符串str中首次出现子字符串的索引，如果未找到则返回 -1。

indexOf("apple pie", "pie") == 6

lastIndexOf(str, substring) #

返回字符串str中最后一次出现子字符串的索引，如果未找到则返回 -1。

lastIndexOf("apple pie apple", "apple") == 10

hasPrefix(str, prefix) #

如果字符串str以给定的前缀prefix开头，则返回true。

hasPrefix("HelloWorld", "Hello") == true

hasSuffix(str, suffix) #

如果字符串str以给定的后缀suffix结尾，则返回true。

hasSuffix("HelloWorld", "World") == true

日期函数 #

日期函数内置对 Go time 包的支持。可进行的操作说明：

• 对两个日期进行减法，得到之间相差的时间。

  createdAt - now()
  

• 可以在某一日期上添加指定时间，得到新的日期。

  createdAt + duration("1h")
  

• 支持多个日期之间的比较。

  createdAt > now() - duration("1h")
  

now() #

用于返回当前日期，对应 Go time.Time 函数。例如：

now().Year() == 2024

duration (str) #

返回字符串str对应的时间转换结果，对应 Go time.Duration 函数。有效的时间单位：ns、us、ms、s、m、h

duration("1h").Seconds() == 3600

date(str[, format[, timezone]]) #

将字符串str转换为日期表示。

• 如果提供了可选参数format，则表示需要使用指定日期格式，格式要求与 Go time 包一致。
• 如果提供了可选参数timezone，则表示需要指定日期时区。
• 如果没有提供format参数，则str必须是以下格式之一：
  • 2006-01-02
  • 15:04:05
  • 2006-01-02 15:04:05
  • RFC3339
  • RFC822,
  • RFC850,
  • RFC1123,

示例用法：

date("2023-08-14")
date("15:04:05")
date("2023-08-14T00:00:00Z")
date("2023-08-14 00:00:00", "2006-01-02 15:04:05", "Europe/Zurich")

date 可用的方法：

• Year()：返回年份
• Month()：返回月份（从 1 开始）
• Day()：返回月份中的日期
• Hour()：返回小时
• Minute()：返回分钟
• Second()：返回秒
• Weekday()：返回星期几
• YearDay()：返回年份中的第几天
• 查看更多信息：time.Time

示例用法：

date("2023-08-14").Year() == 2023

timezone(str) #

返回字符串str的时区。

timezone("Europe/Zurich")
timezone("UTC")

使用In()方法可以将日期转换为不同的时区。

date("2023-08-14 00:00:00").In(timezone("Europe/Zurich"))

数值函数 #

max(n1, n2) #

返回n1、n2中的最大值。

max(5, 7) == 7

min(n1, n2) #

返回n1、n2中的最小值。

min(5, 7) == 5

abs(n) #

返回n的绝对值。

abs(-5) == 5

ceil(n) #

返回大于或等于n的最小整数值。

ceil(1.5) == 2.0

floor(n) #

返回小于或等于n的最大整数值。

floor(1.5) == 1.0

round(n) #

返回n进行四舍五入后的整数。

round(1.5) == 2.0

数组函数 #

数组函数常与谓语关联使用，详情了解谓语。

all(array, predicate) #

数组的所有元素满足谓语条件时，返回 true。数组为空也返回 true。

all(tweets, {.Size < 280})

any(array, predicate) #

数组内至少有一个元素满足谓语条件时，返回 true。数组为空也返回 true。

any(tweets, {.Size > 280})

one(array, predicate) #

数组内仅有一个元素满足谓语条件时，返回 true。数组为空也返回 true。

one(participants, {.Winner})

none(array, predicate) #

数组内所有元素都不满足谓语条件时，返回 true。数组为空也返回 true。

none(tweets, {.Size > 280})

map(array, predicate) #

对数组内的每个元素应用谓语条件，并返回新的数组。

map(tweets, {.Size})

filter(array, predicate) #

通过谓语条件过滤数组元素，并返回新的数组。

filter(users, .Name startsWith "J")

find(array, predicate) #

在数组中查找第一个满足谓语条件的元素。

find([1, 2, 3, 4], # > 2) == 3

findIndex(array, predicate) #

在数组中查找第一个满足谓语条件的元素的索引。

findIndex([1, 2, 3, 4], # > 2) == 2

findLast(array, predicate) #

在数组中查找最后一个满足谓语条件的元素。

findLast([1, 2, 3, 4], # > 2) == 4

findLastIndex(array, predicate) #

在数组中查找最后一个满足谓语条件的元素的索引。

findLastIndex([1, 2, 3, 4], # > 2) == 3

groupBy(array, predicate) #

根据谓语条件对数组元素进行分组。

groupBy(users, .Age)

count(array[, predicate]) #

返回满足谓语条件的数组元素数量。

count(users, .Age > 18)

等价于：

len(filter(users, .Age > 18))

concat(array1, array2[, ...]) #

按顺序连接两个或多个数组。

concat([1, 2], [3, 4]) == [1, 2, 3, 4]

join(array[, delimiter]) #

将字符串数组内的元素用给定的分隔符连接成一个字符串。如果未提供分隔符，则直接连接字符串数组元素。

join(["apple", "orange", "grape"], ",") == "apple,orange,grape"
join(["apple", "orange", "grape"]) == "appleorangegrape"

reduce(array, predicate[, initialValue]) #

对数组内的每个元素应用谓语条件，将数组简化为单个值。可选参数initialValue用于指定累加器的初始值。如果没有提供initialValue参数值，则默认使用数组内的第一个元素作为初始值。
谓语条件（predicate参数）支持的变量：

• #：表示当前元素
• #acc：累加器
• #index：当前元素的索引

示例用法：

reduce(1..9, #acc + #)
reduce(1..9, #acc + #, 0)

sum(array[, predicate]) #

返回数组中所有数字的和。

sum([1, 2, 3]) == 6

如果提供了可选的谓语条件（predicate参数），则先对每个元素应用谓语条件，再相加计算和。

sum(accounts, .Balance)

等价于：

reduce(accounts, #acc + .Balance, 0)
// or
sum(map(accounts, .Balance))

mean(array) #

返回数组中所有数字的平均值。

mean([1, 2, 3]) == 2.0

median(array) #

返回数组中所有数字的中位数。

median([1, 2, 3]) == 2.0

first(array) #

返回数组中的第一个元素。如果数组为空，则返回nil。

first([1, 2, 3]) == 1

last(array) #

返回数组中的最后一个元素。如果数组为空，则返回nil。

last([1, 2, 3]) == 3

take(array, n) #

返回数组中的前 n 个元素。如果数组元素少于 n 个，则返回整个数组。

take([1, 2, 3, 4], 2) == [1, 2]

reverse(array) #

将数组元素倒序排列。

reverse([3, 1, 4]) == [4, 1, 3]
reverse(reverse([3, 1, 4])) == [3, 1, 4]

sort(array[, order]) #

将数组元素升序排列。

sort([3, 1, 4]) == [1, 3, 4]
sort([3, 1, 4], "desc") == [4, 3, 1]

sortBy(array[, predicate, order]) #

根据谓语条件对数组元素排序。可选参数order用于指定排序的顺序：asc（升序）或desc（降序）。

sortBy(users, .Age)
sortBy(users, .Age, "desc")

Map 函数 #

keys(map) #

返回 Map 键值对集合内所有的键。

keys({"name": "John", "age": 30}) == ["name", "age"]

values(map) #

返回 Map 键值对集合内所有的值。

values({"name": "John", "age": 30}) == ["John", 30]

类型转换函数 #

type(v) #

返回给定值v对应的数据类型。可能值有：

• nil
• bool
• int
• uint
• float
• string
• array
• map
• 数据结构会返回类型名称

示例用法：

type(42) == "int"
type("hello") == "string"
type(now()) == "time.Time"

int(v) #

返回数字或字符串的整数值。

int("123") == 123

float(v) #

返回数字或字符串的浮点值。

float("123.45") == 123.45

string(v) #

将给定值v转换为字符串。

string(123) == "123"

toJSON(v) #

将给定值v转换为 JSON 字符串。

toJSON({"name": "John", "age": 30})

fromJSON(v) #

解析给定的 JSON 字符串v，并返回相应的值。

fromJSON('{"name": "John", "age": 30}')

toBase64(v) #

将字符串v编码为 Base64 格式。

toBase64("Hello World") == "SGVsbG8gV29ybGQ="

fromBase64(v) #

将 Base64 编码的字符串v解码回其原始形式。

fromBase64("SGVsbG8gV29ybGQ=") == "Hello World"

toPairs(map) #

将 Map 键值对集合转换为键值对数组。

toPairs({"name": "John", "age": 30}) == [["name", "John"], ["age", 30]]

fromPairs(array) #

将键值对数组转换为 Map 键值对集合。

fromPairs([["name", "John"], ["age", 30]]) == {"name": "John", "age": 30}

其他函数 #

len(v) #

返回数组、Map 集合或者字符串的长度。

len([1, 2, 3]) == 3
len({"name": "John", "age": 30}) == 2
len("Hello") == 5

get(v, index) #

从数组、Map 集合中，检索指定索引的元素。

• 如果索引超过数组、Map 集合的范围，则返回nil。
• 如果 Map 集合的键不存在，则返回nil。

get([1, 2, 3], 1) == 2
get({"name": "John", "age": 30}, "name") == "John"

位运算函数 #

bitand(int, int) #

返回位与操作的结果。

bitand(0b1010, 0b1100) == 0b1000

bitor(int, int) #

返回位或操作的结果。

bitor(0b1010, 0b1100) == 0b1110

bitxor(int, int) #

返回位异或操作的结果。

bitxor(0b1010, 0b1100) == 0b110

bitnand(int, int) #

返回位与非操作的结果。

bitnand(0b1010, 0b1100) == 0b10

bitnot(int) #

返回位非操作的结果。

bitnot(0b1010) == -0b1011

bitshl(int, int) #

返回左移操作的结果。

bitshl(0b101101, 2) == 0b10110100

bitshr(int, int) #

返回右移操作的结果。

bitshr(0b101101, 2) == 0b1011

bitushr(int, int) #

返回无符号右移操作的结果。

bitushr(-0b101, 2) == 4611686018427387902