模板函数列表

Helm 包含许多模板函数，你可以在模板中利用它们。它们列在这里，并按以下类别细分

• 密码学和安全
• 日期
• 字典
• 编码
• 文件路径
• Kubernetes 和图表
• 逻辑和流程控制
• 列表
• 数学
• 浮点数学
• 网络
• 反射
• 正则表达式
• 语义版本
• 字符串
• 类型转换
• URL
• UUID

逻辑和流程控制函数

Helm 包含许多逻辑和控制流函数，包括 and、coalesce、default、empty、eq、fail、ge、gt、le、lt、ne、not、or 和 required。

and

返回两个或多个参数的布尔 AND（第一个空参数或最后一个参数）。

and .Arg1 .Arg2

or

返回两个或多个参数的布尔 OR（第一个非空参数或最后一个参数）。

or .Arg1 .Arg2

not

返回其参数的布尔否定。

not .Arg

eq

返回参数的布尔相等性（例如，Arg1 == Arg2）。

eq .Arg1 .Arg2

ne

返回参数的布尔不相等性（例如，Arg1 != Arg2）

ne .Arg1 .Arg2

lt

如果第一个参数小于第二个参数，则返回布尔值 true。否则返回 false（例如，Arg1 < Arg2）。

lt .Arg1 .Arg2

le

如果第一个参数小于或等于第二个参数，则返回布尔值 true。否则返回 false（例如，Arg1 <= Arg2）。

le .Arg1 .Arg2

gt

如果第一个参数大于第二个参数，则返回布尔值 true。否则返回 false（例如，Arg1 > Arg2）。

gt .Arg1 .Arg2

ge

如果第一个参数大于或等于第二个参数，则返回布尔值 true。否则返回 false（例如，Arg1 >= Arg2）。

ge .Arg1 .Arg2

default

要设置一个简单的默认值，请使用 default

default "foo" .Bar

在上面，如果 .Bar 评估为非空值，则将使用它。但如果它是空的，则将返回 foo。

"空" 的定义取决于类型

• 数值：0
• 字符串：""
• 列表：[]
• 字典：{}
• 布尔值：false
• 以及始终为 nil（即 null）

对于结构体，没有空的定义，因此结构体永远不会返回默认值。

required

使用 required 指定必须设置的值

required "A valid foo is required!" .Bar

如果 .Bar 为空或未定义（请参阅 default 如何评估这一点），模板将不会呈现，并将返回提供的错误消息。

empty

empty 函数在给定值为“空”时返回 true，否则返回 false。“空”值列在 default 部分中。

empty .Foo

请注意，在 Go 模板条件语句中，空值会自动计算。因此，你很少需要 if not empty .Foo。只需使用 if .Foo 即可。

fail

无条件返回一个空的 string 和一个带有指定文本的 error。这在其他条件语句已确定模板呈现应失败的情况下很有用。

fail "Please accept the end user license agreement"

coalesce

coalesce 函数接受一个值列表，并返回第一个非空值。

coalesce 0 1 2

以上返回 1。

此函数对于扫描多个变量或值很有用

coalesce .name .parent.name "Matt"

以上将首先检查 .name 是否为空。如果不是，它将返回该值。如果它是空的，coalesce 将评估 .parent.name 是否为空。最后，如果 .name 和 .parent.name 都为空，它将返回 Matt。

ternary

ternary 函数接受两个值和一个测试值。如果测试值为真，将返回第一个值。如果测试值为“空”，将返回第二个值。这类似于 C 和其他编程语言中的三元运算符。

真测试值

ternary "foo" "bar" true

or

true | ternary "foo" "bar"

以上返回 "foo"。

假测试值

ternary "foo" "bar" false

or

false | ternary "foo" "bar"

以上返回 "bar"。

字符串函数

Helm 包含以下字符串函数：abbrev、abbrevboth、camelcase、cat、contains、hasPrefix、hasSuffix、indent、initials、kebabcase、lower、nindent、nospace、plural、print、printf、println、quote、randAlpha、randAlphaNum、randAscii、randNumeric、repeat、replace、shuffle、snakecase、squote、substr、swapcase、title、trim、trimAll、trimPrefix、trimSuffix、trunc、untitle、upper、wrap 和 wrapWith。

print

从其各部分的组合返回一个字符串。

print "Matt has " .Dogs " dogs"

只要有可能，非字符串类型就会被转换为字符串。

请注意，当两个相邻参数不是字符串时，会在它们之间添加一个空格。

println

与 print 的工作方式相同，但在末尾添加一个新行。

printf

根据格式化字符串及其按顺序传递给它的参数返回一个字符串。

printf "%s has %d dogs." .Name .NumberDogs

要使用的占位符取决于正在传递的参数的类型。这包括

通用

• %v 默认格式的值
  • 打印字典时，加号标志 (%+v) 会添加字段名称
• %% 一个字面百分号；不消耗任何值

布尔值

• %t true 或 false 关键字

整数

• %b 2 进制
• %c 由对应 Unicode 代码点表示的字符
• %d 10 进制
• %o 8 进制
• %O 带有 0o 前缀的 8 进制
• %q 一个安全转义的单引号字符字面量
• %x 16 进制，使用小写字母表示 a-f
• %X 16 进制，使用大写字母表示 A-F
• %U Unicode 格式：U+1234；与 "U+%04X" 相同

浮点数和复数成分

• %b 十进制的非科学记数法，指数为 2 的幂，例如 -123456p-78
• %e 科学记数法，例如 -1.234456e+78
• %E 科学记数法，例如 -1.234456E+78
• %f 十进制点，但没有指数，例如 123.456
• %F 是 %f 的同义词
• %g 对于大指数使用 %e，对于其他情况使用 %f。
• %G 对于大指数使用 %E，对于其他情况使用 %F
• %x 十六进制记数法（带有十进制的 2 的幂指数），例如 -0x1.23abcp+20
• %X 大写十六进制记数法，例如 -0X1.23ABCP+20

字符串和字节切片（使用这些动词时等效处理）

• %s 字符串或切片的未解释字节
• %q 一个安全转义的双引号字符串
• %x 16 进制，小写，每字节两个字符
• %X 16 进制，大写，每字节两个字符

切片

• %p 第 0 个元素的地址，以 16 进制表示，带有前导 0x

trim

trim 函数从字符串的两端移除空格

trim "   hello    "

以上产生 hello

trimAll

从字符串的前后移除给定的字符

trimAll "$" "$5.00"

以上返回 5.00（作为字符串）。

trimPrefix

只从字符串中移除前缀

trimPrefix "-" "-hello"

以上返回 hello

trimSuffix

只从字符串中移除后缀

trimSuffix "-" "hello-"

以上返回 hello

lower

将整个字符串转换为小写

lower "HELLO"

以上返回 hello

upper

将整个字符串转换为大写

upper "hello"

以上返回 HELLO

title

转换为标题大小写

title "hello world"

以上返回 Hello World

untitle

移除标题大小写。untitle "Hello World" 产生 hello world。

repeat

重复一个字符串多次

repeat 3 "hello"

以上返回 hellohellohello

substr

从字符串中获取子字符串。它接受三个参数

• 开始 (int)
• 结束 (int)
• 字符串 (string)

substr 0 5 "hello world"

以上返回 hello

nospace

从字符串中删除所有空格。

nospace "hello w o r l d"

以上返回 helloworld

trunc

截断字符串

trunc 5 "hello world"

以上产生 hello。

trunc -5 "hello world"

以上产生 world。

abbrev

使用省略号 (...) 截断字符串

参数

• 最大长度
• 字符串

abbrev 5 "hello world"

以上返回 he...，因为它将省略号的宽度计入最大长度。

abbrevboth

两端缩写

abbrevboth 5 10 "1234 5678 9123"

以上产生 ...5678...

它接受

• 左偏移量
• 最大长度
• 字符串

首字母

给定多个单词，取每个单词的首字母并组合。

initials "First Try"

以上返回 FT

randAlphaNum、randAlpha、randNumeric 和 randAscii

这四个函数生成密码学安全的 (使用 crypto/rand) 随机字符串，但具有不同的基本字符集

• randAlphaNum 使用 0-9a-zA-Z
• randAlpha 使用 a-zA-Z
• randNumeric 使用 0-9
• randAscii 使用所有可打印的 ASCII 字符

它们每个都接受一个参数：字符串的整数长度。

randNumeric 3

以上将产生一个包含三位数字的随机字符串。

wrap

在给定的列数处换行文本

wrap 80 $someText

以上将把 $someText 中的字符串换行到 80 列。

wrapWith

wrapWith 的工作方式与 wrap 相同，但允许您指定要换行的字符串。（wrap 使用 \n）

wrapWith 5 "\t" "Hello World"

以上产生 Hello World（其中空格是 ASCII 制表符）

contains

测试一个字符串是否包含在另一个字符串中

contains "cat" "catch"

以上返回 true，因为 catch 包含 cat。

hasPrefix 和 hasSuffix

hasPrefix 和 hasSuffix 函数测试字符串是否具有给定的前缀或后缀

hasPrefix "cat" "catch"

以上返回 true，因为 catch 具有前缀 cat。

quote 和 squote

这些函数将字符串用双引号 (quote) 或单引号 (squote) 括起来。

cat

cat 函数将多个字符串连接在一起，用空格分隔。

cat "hello" "beautiful" "world"

以上产生 hello beautiful world

indent

indent 函数将给定字符串中的每一行缩进到指定的缩进宽度。这在对齐多行字符串时很有用

indent 4 $lots_of_text

以上将用 4 个空格字符缩进文本的每一行。

nindent

nindent 函数与 indent 函数相同，但会在字符串开头添加一个新行。

nindent 4 $lots_of_text

以上将用 4 个空格字符缩进文本的每一行，并在开头添加一个新行。

replace

执行简单的字符串替换。

它接受三个参数

• 要替换的字符串
• 要替换成的字符串
• 源字符串

"I Am Henry VIII" | replace " " "-"

以上将产生 I-Am-Henry-VIII

plural

将字符串变为复数形式。

len $fish | plural "one anchovy" "many anchovies"

在以上示例中，如果字符串的长度为 1，则将打印第一个参数 (one anchovy)。否则，将打印第二个参数 (many anchovies)。

参数是

• 单数字符串
• 复数字符串
• 长度整数

注意：Helm 目前不支持具有更复杂复数规则的语言。而 0 被视为复数，因为英语将它视为复数 (zero anchovies)。

snakecase

将字符串从 camelCase 转换为 snake_case。

snakecase "FirstName"

以上将产生 first_name。

camelcase

将字符串从 snake_case 转换为 CamelCase

camelcase "http_server"

以上将产生 HttpServer。

kebabcase

将字符串从 camelCase 转换为 kebab-case。

kebabcase "FirstName"

以上将产生 first-name。

swapcase

使用基于单词的算法交换字符串的大小写。

转换算法

• 大写字母转换为小写字母
• 标题大小写字母转换为小写字母
• 空格后或开头的 小写字母 转换为 标题大小写
• 其他小写字母转换为大写字母
• 空格由 unicode.IsSpace(char) 定义

swapcase "This Is A.Test"

以上将产生 tHIS iS a.tEST。

shuffle

洗牌字符串。

shuffle "hello"

以上将随机化 hello 中的字母，可能产生 oelhl。

类型转换函数

Helm 提供以下类型转换函数

• atoi：将字符串转换为整数。
• float64：转换为 float64。
• int：转换为系统宽度上的 int。
• int64：转换为 int64。
• toDecimal：将 Unix 八进制转换为 int64。
• toString：转换为字符串。
• toStrings：将列表、切片或数组转换为字符串列表。
• toJson (mustToJson)：将列表、切片、数组、字典或对象转换为 JSON。
• toPrettyJson (mustToPrettyJson)：将列表、切片、数组、字典或对象转换为缩进的 JSON。
• toRawJson (mustToRawJson)：将列表、切片、数组、字典或对象转换为 JSON，HTML 字符不转义。
• fromYaml：将 YAML 字符串转换为对象。
• fromJson：将 JSON 字符串转换为对象。
• fromJsonArray：将 JSON 数组转换为列表。
• toYaml：将列表、切片、数组、字典或对象转换为缩进的 yaml，可用于从任何源复制 yaml 块。此函数等效于 GoLang yaml.Marshal 函数，请参阅此处文档：https://pkg.go.dev/gopkg.in/yaml.v2#Marshal
• toToml：将列表、切片、数组、字典或对象转换为 toml，可用于从任何源复制 toml 块。
• fromYamlArray：将 YAML 数组转换为列表。

只有 atoi 要求输入为特定类型。其他函数将尝试从任何类型转换为目标类型。例如，int64 可以将浮点数转换为整数，也可以将字符串转换为整数。

toStrings

给定一个类似列表的集合，生成一个字符串切片。

list 1 2 3 | toStrings

以上将 1 转换为 "1"，2 转换为 "2"，依此类推，然后将它们作为列表返回。

toDecimal

给定一个 Unix 八进制权限，生成一个十进制数。

"0777" | toDecimal

以上将 0777 转换为 511 并将该值作为 int64 返回。

toJson、mustToJson

toJson 函数将项目编码为 JSON 字符串。如果项目无法转换为 JSON，该函数将返回一个空字符串。mustToJson 在项目无法编码为 JSON 时将返回一个错误。

toJson .Item

以上返回 .Item 的 JSON 字符串表示形式。

toPrettyJson、mustToPrettyJson

toPrettyJson 函数将项目编码为漂亮的（缩进的）JSON 字符串。

toPrettyJson .Item

以上返回 .Item 的缩进 JSON 字符串表示形式。

toRawJson、mustToRawJson

toRawJson 函数将项目编码为 JSON 字符串，HTML 字符不转义。

toRawJson .Item

以上返回 .Item 的不转义 JSON 字符串表示形式。

fromYaml

fromYaml 函数接受一个 YAML 字符串，并返回一个可以在模板中使用的对象。

文件位于：yamls/person.yaml

name: Bob
age: 25
hobbies:
  - hiking
  - fishing
  - cooking

{{- $person := .Files.Get "yamls/person.yaml" | fromYaml }}
greeting: |
  Hi, my name is {{ $person.name }} and I am {{ $person.age }} years old.
  My hobbies are {{ range $person.hobbies }}{{ . }} {{ end }}.  

fromJson

fromJson 函数接受一个 JSON 字符串，并返回一个可以在模板中使用的对象。

文件位于：jsons/person.json

{
  "name": "Bob",
  "age": 25,
  "hobbies": [
    "hiking",
    "fishing",
    "cooking"
  ]
}

{{- $person := .Files.Get "jsons/person.json" | fromJson }}
greeting: |
  Hi, my name is {{ $person.name }} and I am {{ $person.age }} years old.
  My hobbies are {{ range $person.hobbies }}{{ . }} {{ end }}.  

fromJsonArray

fromJsonArray 函数接受一个 JSON 数组，并返回一个可以在模板中使用的列表。

文件位于：jsons/people.json

[
 { "name": "Bob","age": 25 },
 { "name": "Ram","age": 16 }
]

{{- $people := .Files.Get "jsons/people.json" | fromJsonArray }}
{{- range $person := $people }}
greeting: |
    Hi, my name is {{ $person.name }} and I am {{ $person.age }} years old.
{{ end }}

fromYamlArray

fromYamlArray 函数接受一个 YAML 数组，并返回一个可以在模板中使用的列表。

文件位于：yamls/people.yml

- name: Bob
  age: 25
- name: Ram
  age: 16

{{- $people := .Files.Get "yamls/people.yml" | fromYamlArray }}
{{- range $person := $people }}
greeting: |
    Hi, my name is {{ $person.name }} and I am {{ $person.age }} years old.
{{ end }}

正则表达式

Helm 包含以下正则表达式函数：regexFind (mustRegexFind)、regexFindAll (mustRegexFindAll)、regexMatch (mustRegexMatch)、regexReplaceAll (mustRegexReplaceAll)、regexReplaceAllLiteral (mustRegexReplaceAllLiteral)、regexSplit (mustRegexSplit).

regexMatch、mustRegexMatch

如果输入字符串包含正则表达式的任何匹配项，则返回 true。

regexMatch "^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$" "test@acme.com"

以上产生 true

regexMatch 在出现问题时会恐慌，mustRegexMatch 在出现问题时会将错误返回给模板引擎。

regexFindAll、mustRegexFindAll

返回输入字符串中正则表达式的所有匹配项的切片。最后一个参数 n 确定要返回的子字符串数量，其中 -1 表示返回所有匹配项

regexFindAll "[2,4,6,8]" "123456789" -1

以上产生 [2 4 6 8]

regexFindAll 在出现问题时会恐慌，mustRegexFindAll 在出现问题时会将错误返回给模板引擎。

regexFind、mustRegexFind

返回输入字符串中正则表达式的第一个（最左边的）匹配项

regexFind "[a-zA-Z][1-9]" "abcd1234"

以上产生 d1

regexFind 在出现问题时会恐慌，mustRegexFind 在出现问题时会将错误返回给模板引擎。

regexReplaceAll、mustRegexReplaceAll

返回输入字符串的副本，用替换字符串 replacement 替换 Regexp 的匹配项。在替换字符串中，$ 符号的解释与 Expand 中相同，例如 $1 代表第一个子匹配的文本

regexReplaceAll "a(x*)b" "-ab-axxb-" "${1}W"

以上产生 -W-xxW-

regexReplaceAll 在出现问题时会恐慌，mustRegexReplaceAll 在出现问题时会将错误返回给模板引擎。

regexReplaceAllLiteral、mustRegexReplaceAllLiteral

返回输入字符串的副本，用替换字符串 replacement 替换 Regexp 的匹配项。替换字符串直接替换，不使用 Expand

regexReplaceAllLiteral "a(x*)b" "-ab-axxb-" "${1}"

以上产生 -${1}-${1}-

regexReplaceAllLiteral 在出现问题时会恐慌，mustRegexReplaceAllLiteral 在出现问题时会将错误返回给模板引擎。

regexSplit、mustRegexSplit

将输入字符串切片为由表达式分隔的子字符串，并返回这些表达式匹配项之间的子字符串的切片。最后一个参数 n 确定要返回的子字符串数量，其中 -1 表示返回所有匹配项

regexSplit "z+" "pizza" -1

以上产生 [pi a]

regexSplit 在出现问题时会恐慌，mustRegexSplit 在出现问题时会将错误返回给模板引擎。

密码学和安全功能

Helm 提供了一些高级密码学功能。它们包括 adler32sum、buildCustomCert、decryptAES、derivePassword、encryptAES、genCA、genPrivateKey、genSelfSignedCert、genSignedCert、htpasswd、sha1sum 和 sha256sum.

sha1sum

sha1sum 函数接收一个字符串，并计算其 SHA1 摘要。

sha1sum "Hello world!"

sha256sum

sha256sum 函数接收一个字符串，并计算其 SHA256 摘要。

sha256sum "Hello world!"

以上将以“ASCII 盔甲”格式计算 SHA 256 校验和，该格式可以安全地打印。

adler32sum

adler32sum 函数接收一个字符串，并计算其 Adler-32 校验和。

adler32sum "Hello world!"

htpasswd

htpasswd 函数接受 username 和 password，并生成 password 的 bcrypt 哈希值。结果可用于在 Apache HTTP Server 上进行基本身份验证。

htpasswd "myUser" "myPassword"

请注意，将密码直接存储在模板中是不安全的。

derivePassword

derivePassword 函数可用于根据一些共享的“主密码”约束派生特定密码。此算法是 明确指定 的。

derivePassword 1 "long" "password" "user" "example.com"

请注意，将各个部分直接存储在模板中被认为是不安全的。

genPrivateKey

genPrivateKey 函数生成一个新私钥，并将其编码为 PEM 块。

它接受第一个参数的其中一个值

• ecdsa：生成一个椭圆曲线 DSA 密钥 (P256)
• dsa: 生成 DSA 密钥 (L2048N256)
• rsa: 生成 RSA 4096 密钥

buildCustomCert

buildCustomCert 函数允许自定义证书。

它接收以下字符串参数

• 一个 Base64 编码的 PEM 格式证书
• 一个 Base64 编码的 PEM 格式私钥

它返回一个具有以下属性的证书对象

• Cert: 一个 PEM 编码的证书
• Key: 一个 PEM 编码的私钥

示例

$ca := buildCustomCert "base64-encoded-ca-crt" "base64-encoded-ca-key"

请注意，返回的对象可以传递给 genSignedCert 函数，以使用此 CA 签署证书。

genCA

genCA 函数生成一个新的自签名 x509 证书颁发机构。

它接收以下参数

• 主题的通用名 (cn)
• 证书有效期（以天为单位）

它返回一个具有以下属性的对象

• Cert: 一个 PEM 编码的证书
• Key: 一个 PEM 编码的私钥

示例

$ca := genCA "foo-ca" 365

请注意，返回的对象可以传递给 genSignedCert 函数，以使用此 CA 签署证书。

genSelfSignedCert

genSelfSignedCert 函数生成一个新的自签名 x509 证书。

它接收以下参数

• 主题的通用名 (cn)
• 可选的 IP 列表；可以为空
• 可选的备用 DNS 名称列表；可以为空
• 证书有效期（以天为单位）

它返回一个具有以下属性的对象

• Cert: 一个 PEM 编码的证书
• Key: 一个 PEM 编码的私钥

示例

$cert := genSelfSignedCert "foo.com" (list "10.0.0.1" "10.0.0.2") (list "bar.com" "bat.com") 365

genSignedCert

genSignedCert 函数生成一个新的由指定 CA 签名的 x509 证书。

它接收以下参数

• 主题的通用名 (cn)
• 可选的 IP 列表；可以为空
• 可选的备用 DNS 名称列表；可以为空
• 证书有效期（以天为单位）
• CA (见 genCA)

示例

$ca := genCA "foo-ca" 365
$cert := genSignedCert "foo.com" (list "10.0.0.1" "10.0.0.2") (list "bar.com" "bat.com") 365 $ca

encryptAES

encryptAES 函数使用 AES-256 CBC 加密文本，并返回一个 Base64 编码的字符串。

encryptAES "secretkey" "plaintext"

decryptAES

decryptAES 函数接收一个由 AES-256 CBC 算法编码的 Base64 字符串，并返回解码后的文本。

"30tEfhuJSVRhpG97XCuWgz2okj7L8vQ1s6V9zVUPeDQ=" | decryptAES "secretkey"

日期函数

Helm 包含以下日期函数，您可以在模板中使用：ago，date，dateInZone，dateModify (mustDateModify)，duration，durationRound，htmlDate，htmlDateInZone，now，toDate (mustToDate)，以及unixEpoch。

now

当前日期/时间。将其与其他日期函数结合使用。

ago

ago 函数返回自时间的持续时间。现在以秒分辨率。

ago .CreatedAt

以 time.Duration String() 格式返回

2h34m7s

date

date 函数格式化日期。

将日期格式化为 YEAR-MONTH-DAY

now | date "2006-01-02"

Go 中的日期格式化有点不同。

简而言之，将此作为基准日期

Mon Jan 2 15:04:05 MST 2006

以您想要的格式编写。上面，2006-01-02 是同一个日期，但以我们想要的格式。

dateInZone

与 date 相同，但带有时区。

dateInZone "2006-01-02" (now) "UTC"

duration

将给定的秒数格式化为 time.Duration。

这将返回 1m35s

duration 95

durationRound

将给定的持续时间舍入到最显著的单位。字符串和 time.Duration 将被解析为持续时间，而 time.Time 将被计算为自时的持续时间。

这将返回 2h

durationRound "2h10m5s"

这将返回 3mo

durationRound "2400h10m5s"

unixEpoch

返回 time.Time 自 Unix 纪元以来的秒数。

now | unixEpoch

dateModify, mustDateModify

dateModify 函数接收一个修改和一个日期，并返回时间戳。

从当前时间减去一个小时三十分钟

now | dateModify "-1.5h"

如果修改格式错误，dateModify 将返回未修改的日期。mustDateModify 将返回错误，否则。

htmlDate

htmlDate 函数格式化日期，以便插入 HTML 日期选择器输入字段。

now | htmlDate

htmlDateInZone

与 htmlDate 相同，但带有时区。

htmlDateInZone (now) "UTC"

toDate, mustToDate

toDate 将字符串转换为日期。第一个参数是日期布局，第二个是日期字符串。如果字符串无法转换，它将返回零值。mustToDate 将在字符串无法转换的情况下返回错误。

当您想要将字符串日期转换为另一种格式（使用管道）时，这很有用。下面的示例将“2017-12-31”转换为“31/12/2017”。

toDate "2006-01-02" "2017-12-31" | date "02/01/2006"

字典和字典函数

Helm 提供了一种名为 dict（表示“字典”，如 Python 中）的键值存储类型。dict 是一个无序类型。

字典的键**必须是字符串**。但是，值可以是任何类型，甚至是另一个 dict 或 list。

与 list 不同，dict 不是不可变的。set 和 unset 函数将修改字典的内容。

Helm 提供以下函数来支持使用字典：deepCopy (mustDeepCopy)，dict，dig，get，hasKey，keys，merge (mustMerge)，mergeOverwrite (mustMergeOverwrite)，omit，pick，pluck，set，unset，以及values。

dict

创建字典是通过调用 dict 函数并向其传递一个键值对列表来完成的。

以下创建了一个包含三个项目的字典

$myDict := dict "name1" "value1" "name2" "value2" "name3" "value 3"

get

给定一个映射和一个键，从映射中获取值。

get $myDict "name1"

以上返回 "value1"

请注意，如果找不到键，此操作将简单地返回 ""。不会生成错误。

set

使用 set 向字典添加新的键值对。

$_ := set $myDict "name4" "value4"

请注意，set *返回字典*（这是 Go 模板函数的要求），因此您可能需要像上面使用 $_ 赋值那样捕获该值。

unset

给定一个映射和一个键，从映射中删除键。

$_ := unset $myDict "name4"

与 set 一样，这将返回字典。

请注意，如果找不到键，此操作将简单地返回。不会生成错误。

hasKey

hasKey 函数如果给定的字典包含给定的键，则返回 true。

hasKey $myDict "name1"

如果找不到键，则返回 false。

pluck

pluck 函数使您能够提供一个键和多个映射，并获取所有匹配项的列表

pluck "name1" $myDict $myOtherDict

以上将返回一个包含每个找到的值的 list（[value1 otherValue1]）。

如果在映射中 *找不到* 给定的键，则该映射在列表中将没有项目（返回列表的长度将小于 pluck 调用中的字典数量）。

如果 *找到* 键但值为一个空值，则该值将被插入。

Helm 模板中的一个常见习惯用法是使用 pluck... | first 从字典集合中获取第一个匹配的键。

dig

dig 函数遍历一组嵌套的字典，从一个值列表中选择键。如果在关联的字典中找不到任何键，它将返回一个默认值。

dig "user" "role" "humanName" "guest" $dict

给定一个结构类似于以下的字典

{
  user: {
    role: {
      humanName: "curator"
    }
  }
}

以上将返回 "curator"。如果字典甚至缺少 user 字段，结果将是 "guest"。

Dig 在您想避免使用保护子句的情况下非常有用，尤其是在 Go 的模板包的 and 不会进行短路的情况下。例如，and a.maybeNil a.maybeNil.iNeedThis 将始终评估 a.maybeNil.iNeedThis，如果 a 缺少 maybeNil 字段，则会引发恐慌。）

dig 接受其字典参数作为最后一个参数，以便支持管道。例如

merge a b c | dig "one" "two" "three" "<missing>"

merge, mustMerge

将两个或多个字典合并为一个，优先考虑目标字典

给定

dst:
  default: default
  overwrite: me
  key: true

src:
  overwrite: overwritten
  key: false

将导致

newdict:
  default: default
  overwrite: me
  key: true

$newdict := merge $dest $source1 $source2

这是一个深度合并操作，但不是深度复制操作。合并的嵌套对象在两个字典中都是同一个实例。如果您想要深度复制以及合并，则可以使用 deepCopy 函数以及合并。例如，

deepCopy $source | merge $dest

mustMerge 将在合并不成功的情况下返回错误。

mergeOverwrite, mustMergeOverwrite

将两个或多个字典合并为一个，优先级从**右到左**，有效地覆盖目标字典中的值

给定

dst:
  default: default
  overwrite: me
  key: true

src:
  overwrite: overwritten
  key: false

将导致

newdict:
  default: default
  overwrite: overwritten
  key: false

$newdict := mergeOverwrite $dest $source1 $source2

这是一个深度合并操作，但不是深度复制操作。合并的嵌套对象在两个字典中都是同一个实例。如果您想要深度复制以及合并，则可以使用 deepCopy 函数以及合并。例如，

deepCopy $source | mergeOverwrite $dest

mustMergeOverwrite 将在合并不成功的情况下返回错误。

keys

keys 函数将返回一个或多个 dict 类型中所有键的 list。由于字典是无序的，因此键将不会以可预测的顺序排列。它们可以使用 sortAlpha 进行排序。

keys $myDict | sortAlpha

当提供多个字典时，键将被连接。使用 uniq 函数以及 sortAlpha 来获取一个唯一的排序键列表。

keys $myDict $myOtherDict | uniq | sortAlpha

pick

pick 函数仅从字典中选择给定的键，创建一个新的 dict。

$new := pick $myDict "name1" "name2"

以上返回 {name1: value1, name2: value2}

omit

omit 函数类似于 pick，但它返回一个新的 dict，其中包含与给定键 *不匹配* 的所有键。

$new := omit $myDict "name1" "name3"

以上返回 {name2: value2}

values

values 函数类似于 keys，但它返回一个新的 list，其中包含源 dict 的所有值（仅支持一个字典）。

$vals := values $myDict

以上返回 list["value1", "value2", "value 3"]。请注意，values 函数不保证结果顺序；如果您关心这一点，请使用 sortAlpha。

deepCopy, mustDeepCopy

deepCopy 和 mustDeepCopy 函数接收一个值，并对其进行深度复制。这包括字典和其他结构。deepCopy 在出现问题时会引发恐慌，而 mustDeepCopy 在出现错误时会向模板系统返回错误。

dict "a" 1 "b" 2 | deepCopy

关于字典内部结构的说明

dict 在 Go 中实现为 map[string]interface{}。Go 开发人员可以将 map[string]interface{} 值传递到上下文中，以使它们作为 dict 可供模板使用。

编码函数

Helm 具有以下编码和解码函数

• b64enc/b64dec: 使用 Base64 编码或解码
• b32enc/b32dec: 使用 Base32 编码或解码

列表和列表函数

Helm 提供了一个简单的 list 类型，它可以包含任意顺序的数据列表。这类似于数组或切片，但列表被设计为不可变数据类型。

创建一个整数列表

$myList := list 1 2 3 4 5

以上创建了一个 [1 2 3 4 5] 列表。

Helm 提供以下列表函数：append (mustAppend)，compact (mustCompact)，concat，first (mustFirst)，has (mustHas)，initial (mustInitial)，last (mustLast)，prepend (mustPrepend)，rest (mustRest)，reverse (mustReverse)，seq，index，slice (mustSlice)，uniq (mustUniq)，until，untilStep，以及without (mustWithout)。

first, mustFirst

要获取列表中的第一个项目，请使用 first。

first $myList 返回 1

first 在出现问题时会引发恐慌，而 mustFirst 在出现问题时会向模板引擎返回错误。

rest, mustRest

要获取列表的尾部（除了第一个项目的所有内容），请使用 rest。

rest $myList 返回 [2 3 4 5]

rest 在出现问题时会引发恐慌，而 mustRest 在出现问题时会向模板引擎返回错误。

last, mustLast

要获取列表中的最后一个项目，请使用 last

last $myList 返回 5。这与反转列表然后调用 first 类似。

initial, mustInitial

这通过返回除最后一个元素之外的所有元素来补充 last。initial $myList 返回 [1 2 3 4]。

initial 在出现问题时会引发恐慌，而 mustInitial 在出现问题时会向模板引擎返回错误。

append, mustAppend

将新项目追加到现有列表中，创建一个新列表。

$new = append $myList 6

上述操作将$new 设置为 [1 2 3 4 5 6]。$myList 将保持不变。

如果出现问题，append 会出现恐慌，而 mustAppend 会向模板引擎返回错误。

prepend, mustPrepend

将一个元素推送到列表的前面，创建一个新的列表。

prepend $myList 0

上述操作将生成 [0 1 2 3 4 5]。$myList 将保持不变。

如果出现问题，prepend 会出现恐慌，而 mustPrepend 会向模板引擎返回错误。

concat

将任意数量的列表连接成一个。

concat $myList ( list 6 7 ) ( list 8 )

上述操作将生成 [1 2 3 4 5 6 7 8]。$myList 将保持不变。

reverse, mustReverse

生成一个新的列表，其中包含给定列表中反转的元素。

reverse $myList

上述操作将生成列表 [5 4 3 2 1]。

如果出现问题，reverse 会出现恐慌，而 mustReverse 会向模板引擎返回错误。

uniq, mustUniq

生成一个列表，其中删除了所有重复项。

list 1 1 1 2 | uniq

上述操作将生成 [1 2]

如果出现问题，uniq 会出现恐慌，而 mustUniq 会向模板引擎返回错误。

without, mustWithout

without 函数将项目从列表中过滤掉。

without $myList 3

上述操作将生成 [1 2 4 5]

without 可以接受多个过滤器

without $myList 1 3 5

这将生成 [2 4]

如果出现问题，without 会出现恐慌，而 mustWithout 会向模板引擎返回错误。

has, mustHas

测试列表是否包含特定元素。

has 4 $myList

上述操作将返回 true，而 has "hello" $myList 将返回 false。

如果出现问题，has 会出现恐慌，而 mustHas 会向模板引擎返回错误。

compact, mustCompact

接受一个列表，并删除具有空值的条目。

$list := list 1 "a" "foo" ""
$copy := compact $list

compact 将返回一个新的列表，其中删除了空（即 ""）项。

如果出现问题，compact 会出现恐慌，而 mustCompact 会向模板引擎返回错误。

index

要获取列表的第 n 个元素，请使用 index list [n]。要索引多维列表，请使用 index list [n] [m] ...

• index $myList 0 返回 1。它与 myList[0] 相同
• index $myList 0 1 将与 myList[0][1] 相同

slice, mustSlice

要获取列表的部分元素，请使用 slice list [n] [m]。它等效于 list[n:m]。

• slice $myList 返回 [1 2 3 4 5]。它与 myList[:] 相同。
• slice $myList 3 返回 [4 5]。它与 myList[3:] 相同。
• slice $myList 1 3 返回 [2 3]。它与 myList[1:3] 相同。
• slice $myList 0 3 返回 [1 2 3]。它与 myList[:3] 相同。

如果出现问题，slice 会出现恐慌，而 mustSlice 会向模板引擎返回错误。

until

until 函数构建一系列整数。

until 5

上述操作生成列表 [0, 1, 2, 3, 4]。

这对于使用 range $i, $e := until 5 进行循环很有用。

untilStep

与 until 类似，untilStep 生成一个计数整数列表。但它允许你定义一个开始、停止和步长

untilStep 3 6 2

上述操作将通过从 3 开始，并添加 2 直到它等于或大于 6 来生成 [3 5]。这类似于 Python 的 range 函数。

seq

工作原理与 bash 的 seq 命令相同。

• 1 个参数（end） - 将生成 1 到 end（含）之间的所有计数整数。
• 2 个参数（start, end） - 将生成 start 到 end（含）之间的所有计数整数，以 1 为增量或减量。
• 3 个参数（start, step, end） - 将生成 start 到 end（含）之间的所有计数整数，以 step 为增量或减量。

seq 5       => 1 2 3 4 5
seq -3      => 1 0 -1 -2 -3
seq 0 2     => 0 1 2
seq 2 -2    => 2 1 0 -1 -2
seq 0 2 10  => 0 2 4 6 8 10
seq 0 -2 -5 => 0 -2 -4

数学函数

除非另有说明，否则所有数学函数都对 int64 值进行操作。

以下数学函数可用：add、add1、ceil、div、floor、len、max、min、mod、mul、round 和 sub。

add

使用 add 对数字求和。接受两个或多个输入。

add 1 2 3

add1

要增加 1，请使用 add1。

sub

要减去，请使用 sub。

div

使用 div 执行整数除法。

mod

使用 mod 求模。

mul

使用 mul 乘以。接受两个或多个输入。

mul 1 2 3

max

返回一系列整数中的最大值。

这将返回 3

max 1 2 3

min

返回一系列整数中的最小值。

min 1 2 3 将返回 1。

len

返回参数的长度，表示为整数。

len .Arg

浮点数数学函数

所有数学函数都对 float64 值进行操作。

addf

使用 addf 对数字求和

这将返回 5.5

addf 1.5 2 2

add1f

要增加 1，请使用 add1f

subf

要减去，请使用 subf

这等效于 7.5 - 2 - 3，并将返回 2.5

subf 7.5 2 3

divf

使用 divf 执行整数除法

这等效于 10 / 2 / 4，并将返回 1.25

divf 10 2 4

mulf

使用 mulf 乘以

这将返回 6

mulf 1.5 2 2

maxf

返回一系列浮点数中的最大值

这将返回 3

maxf 1 2.5 3

minf

返回一系列浮点数中的最小值。

这将返回 1.5

minf 1.5 2 3

floor

返回小于或等于输入值的最大的浮点数。

floor 123.9999 将返回 123.0。

ceil

返回大于或等于输入值的最大的浮点数。

ceil 123.001 将返回 124.0。

round

返回一个浮点数，其余部分四舍五入到小数点后的给定位数。

round 123.555555 3 将返回 123.556。

网络函数

Helm 只有一个网络函数，getHostByName。

getHostByName 接收一个域名并返回 IP 地址。

getHostByName "www.google.com" 将返回 www.google.com 的对应 IP 地址。

文件路径函数

虽然 Helm 模板函数不授予对文件系统的访问权限，但它们确实提供了一些函数用于处理遵循文件路径约定的字符串。这些包括 base、clean、dir、ext 和 isAbs。

base

返回路径的最后一个元素。

base "foo/bar/baz"

上述操作将打印 "baz"。

dir

返回目录，剥离路径的最后一部分。因此，dir "foo/bar/baz" 返回 foo/bar。

clean

清理路径。

clean "foo/bar/../baz"

上述操作将解析 .. 并返回 foo/baz。

ext

返回文件扩展名。

ext "foo.bar"

上述操作将返回 .bar。

isAbs

要检查文件路径是否为绝对路径，请使用 isAbs。

反射函数

Helm 提供基本的反射工具。这些工具帮助高级模板开发人员了解特定值的底层 Go 类型信息。Helm 是用 Go 编写的，并且是强类型语言。类型系统在模板中适用。

Go 具有几种基本类型，如 string、slice、int64 和 bool。

Go 具有一个开放的类型系统，允许开发人员创建自己的类型。

Helm 通过 类型函数 和 类型函数 为每种类型提供一组函数。还提供了一个 deepEqual 函数来比较两个值。

类型函数

有两个类型函数：kindOf 返回对象的类型。

kindOf "hello"

上述操作将返回 string。对于简单的测试（如在 if 块中），kindIs 函数将让你验证一个值是否为特定类型

kindIs "int" 123

上述操作将返回 true。

类型函数

类型稍微难以处理，因此有三个不同的函数

• typeOf 返回值的底层类型：typeOf $foo
• typeIs 类似于 kindIs，但用于类型：typeIs "*io.Buffer" $myVal
• typeIsLike 的工作原理与 typeIs 相同，只是它还会取消引用指针

注意： 这些函数都不能测试某项是否实现了给定的接口，因为这样做需要提前编译接口。

deepEqual

deepEqual 返回 true，如果两个值“深度相等”

也适用于非基本类型（与内置的 eq 相比）。

deepEqual (list 1 2 3) (list 1 2 3)

上述操作将返回 true。

语义版本函数

一些版本方案易于解析和比较。Helm 提供了一些函数用于处理 SemVer 2 版本。这些包括 semver 和 semverCompare。在下面，你还会找到有关使用范围进行比较的详细信息。

semver

semver 函数将字符串解析为语义版本

$version := semver "1.2.3-alpha.1+123"

如果解析器失败，它将导致模板执行停止并出现错误。

此时，$version 指向一个具有以下属性的 Version 对象

• $version.Major：主版本号（上面为 1）
• $version.Minor：次版本号（上面为 2）
• $version.Patch：补丁版本号（上面为 3）
• $version.Prerelease：预发布版本（上面为 alpha.1）
• $version.Metadata：构建元数据（上面为 123）
• $version.Original：原始版本，表示为字符串

此外，你可以使用 Compare 函数将 Version 与另一个 version 进行比较

semver "1.4.3" | (semver "1.2.3").Compare

上述操作将返回 -1。

返回值为

• -1，如果给定的 semver 大于调用了 Compare 方法的 semver
• 1，如果调用了 Compare 函数的版本的版本号更大。
• 0，如果它们是同一个版本

（请注意，在 SemVer 中，Metadata 字段在版本比较操作期间不会被比较。）

semverCompare

semverCompare 提供了一个更强大的比较函数。此版本支持版本范围

• semverCompare "1.2.3" "1.2.3" 检查是否完全匹配
• semverCompare "~1.2.0" "1.2.3" 检查主版本和次版本是否匹配，以及第二个版本的补丁版本号是否大于或等于第一个参数。

SemVer 函数使用 Masterminds semver 库，来自 Sprig 的创建者。

基本比较

比较有两个要素。首先，比较字符串是空格或逗号分隔的 AND 比较的列表。然后，这些比较由 ||（OR）比较分隔。例如，">= 1.2 < 3.0.0 || >= 4.2.3" 正在寻找一个大于或等于 1.2 且小于 3.0.0 或大于或等于 4.2.3 的比较。

基本比较是

• =：等于（别名为无运算符）
• !=：不等于
• >：大于
• <：小于
• >=：大于或等于
• <=：小于或等于

处理预发布版本

预发布版本，对于不熟悉的人来说，指的是在稳定版本或正式发布版本之前发布的软件版本。预发布版本的示例包括开发版本、Alpha 版本、Beta 版本和候选发布版本。预发布版本可能是一个版本，例如1.2.3-beta.1，而稳定版本将是1.2.3。在优先级顺序中，预发布版本在相关版本之前。在这个例子中，1.2.3-beta.1 < 1.2.3。

根据语义版本规范，预发布版本可能与它们的发布版本不兼容。它指出：

预发布版本表明该版本不稳定，可能无法满足其关联的正常版本所指定的预期兼容性要求。

使用没有预发布比较器的约束的 SemVer 比较将跳过预发布版本。例如，>=1.2.3 在查看发布版本列表时会跳过预发布版本，而 >=1.2.3-0 会评估并找到预发布版本。

在示例比较中使用 0 作为预发布版本的原因是，根据规范，预发布版本只能包含 ASCII 字母数字和连字符（以及 . 分隔符）。排序根据规范在 ASCII 排序顺序进行。在 ASCII 排序顺序中，最低字符是 0（参见 ASCII 表）。

了解 ASCII 排序顺序很重要，因为 A-Z 在 a-z 之前。这意味着 >=1.2.3-BETA 将返回 1.2.3-alpha。您可能期望的区分大小写在这里不适用。这是由于 ASCII 排序顺序，这是规范中指定的排序方式。

连字符范围比较

有多种方法来处理范围，第一种是连字符范围。它们看起来像

• 1.2 - 1.4.5 等同于 >= 1.2 <= 1.4.5
• 2.3.4 - 4.5 等同于 >= 2.3.4 <= 4.5

比较中的通配符

x、X 和 * 字符可以用作通配符。这适用于所有比较运算符。当用在 = 运算符上时，它将回退到补丁级别比较（见下面的波浪号）。例如，

• 1.2.x 等同于 >= 1.2.0, < 1.3.0
• >= 1.2.x 等同于 >= 1.2.0
• <= 2.x 等同于 < 3
• * 等同于 >= 0.0.0

波浪号范围比较（补丁）

波浪号 (~) 比较运算符用于指定次要版本时的补丁级别范围，以及缺少次要编号时的主要级别更改。例如，

• ~1.2.3 等同于 >= 1.2.3, < 1.3.0
• ~1 等同于 >= 1, < 2
• ~2.3 等同于 >= 2.3, < 2.4
• ~1.2.x 等同于 >= 1.2.0, < 1.3.0
• ~1.x 等同于 >= 1, < 2

插入符号范围比较（主要）

插入符号 (^) 比较运算符用于在发布稳定版本 (1.0.0) 后进行主要级别更改。在 1.0.0 版本之前，次要版本充当 API 稳定级别。这在比较 API 版本时很有用，因为主要更改是 API 颠覆性的。例如，

• ^1.2.3 等同于 >= 1.2.3, < 2.0.0
• ^1.2.x 等同于 >= 1.2.0, < 2.0.0
• ^2.3 等同于 >= 2.3, < 3
• ^2.x 等同于 >= 2.0.0, < 3
• ^0.2.3 等同于 >=0.2.3 <0.3.0
• ^0.2 等同于 >=0.2.0 <0.3.0
• ^0.0.3 等同于 >=0.0.3 <0.0.4
• ^0.0 等同于 >=0.0.0 <0.1.0
• ^0 等同于 >=0.0.0 <1.0.0

URL 函数

Helm 包含 urlParse、urlJoin 和 urlquery 函数，使您能够使用 URL 部分。

urlParse

解析字符串以获取 URL，并生成包含 URL 部分的字典

urlParse "http://admin:secret@server.com:8080/api?list=false#anchor"

以上返回一个字典，包含 URL 对象

scheme:   'http'
host:     'server.com:8080'
path:     '/api'
query:    'list=false'
opaque:   nil
fragment: 'anchor'
userinfo: 'admin:secret'

这是使用来自 Go 标准库的 URL 包实现的。有关更多信息，请查看 https://golang.ac.cn/pkg/net/url/#URL

urlJoin

将映射（由 urlParse 生成）连接起来以生成 URL 字符串

urlJoin (dict "fragment" "fragment" "host" "host:80" "path" "/path" "query" "query" "scheme" "http")

以上返回以下字符串

http://host:80/path?query#fragment

urlquery

返回作为参数传入的值的转义版本，使其适合嵌入 URL 的查询部分。

$var := urlquery "string for query"

UUID 函数

Helm 可以生成 UUID v4 全局唯一标识符。

uuidv4

以上返回一个新的 UUID，类型为 v4（随机生成）。

Kubernetes 和 Chart 函数

Helm 包含用于处理 Kubernetes 的函数，包括 .Capabilities.APIVersions.Has、Files 和 lookup。

lookup

lookup 用于在正在运行的集群中查找资源。在与 helm template 命令一起使用时，它始终返回空响应。

您可以在 lookup 函数文档 中找到更多详细信息。

.Capabilities.APIVersions.Has

返回集群中是否可用 API 版本或资源。

.Capabilities.APIVersions.Has "apps/v1"
.Capabilities.APIVersions.Has "apps/v1/Deployment"

有关更多信息，请查看 内置对象文档。

文件函数

有几个函数可以让您访问图表中的非特殊文件。例如，要访问应用程序配置文件。这些在 访问模板内的文件 中有记录。

注意，许多这些函数的文档来自 Sprig。Sprig 是一个可用于 Go 应用程序的模板函数库。