字符串

字面量

拼音

bl a = "你好abc"            // 字符串
bl b = `原始
字符串`                     // 反引号：原始字符串，不转义，可以换行
bl c = '世'                 // 单引号：单个字符（zifu）

中文

变量 a = "你好abc"          // 字符串
变量 b = `原始
字符串`                     // 反引号：原始字符串，不转义，可以换行
变量 c = '世'               // 单引号：单个字符（rune）

英文

var a = "你好abc"           // 字符串
var b = `原始
字符串`                     // 反引号：原始字符串，不转义，可以换行
var c = '世'                // 单引号：单个字符（rune）

双引号字符串支持的转义只有 \n \t \r \" \\ 五个。

编码

• 字符串类型 zifuchuan（string）内部是 UTF-8，始终是合法的 UTF-8
• 字符类型 zifu（rune）是一个 Unicode 字符
• 字符串方法默认按字符工作，例如 "你好ab" 的长度是 4；需要按字节处理时用 s.utf8（见下文）

运算

拼音

bl s = "ab" +[zifuchuan] "cd"   // 拼接
bl eq = s ==[zifuchuan] "abcd"  // 比较内容
bl ne = s !=[zifuchuan] "xx"

中文

变量 s = "ab" +[string] "cd"    // 拼接
变量 eq = s ==[string] "abcd"   // 比较内容
变量 ne = s !=[string] "xx"

英文

var s = "ab" +[string] "cd"     // 拼接
var eq = s ==[string] "abcd"    // 比较内容
var ne = s !=[string] "xx"

• 字符串只支持 +[zifuchuan]、==[zifuchuan]、!=[zifuchuan]，不支持大小比较
• 不支持 s[i] 下标，取字符用 s.at(i)
• 字符和字符串不能直接比较

字符串方法

方法有拼音名和英文名，没有中文名。位置都按字符计算，从 0 开始。

拼音	英文	说明
changdu()	length()	字符个数
qu(i)	at(i)	取第 i 个字符，越界 panic
zichuan(start, end)	substr(start, end)	截取 [start, end)，越界 panic
chazhao(sub)	find(sub)	子串第一次出现的位置，找不到返回 -1

拼音

bl s = "你好世界"

dayin(s.changdu())          // 4
dayin(s.qu(0))              // 你
dayin(s.zichuan(1, 3))      // 好世
dayin(s.chazhao("世界"))    // 2
dayin(s.chazhao("xx"))      // -1

中文

变量 s = "你好世界"

打印(s.length())            // 4
打印(s.at(0))               // 你
打印(s.substr(1, 3))        // 好世
打印(s.find("世界"))        // 2
打印(s.find("xx"))          // -1

英文

var s = "你好世界"

print(s.length())           // 4
print(s.at(0))              // 你
print(s.substr(1, 3))       // 好世
print(s.find("世界"))       // 2
print(s.find("xx"))         // -1

chazhao 返回的位置可以直接交给 qu 和 zichuan 使用。

切分、修剪、替换等更多函数见标准库 字符串扩展。

遍历

拼音

bl s = "你好"

jishu (c shuyu s) {     // c 是 zifu
    dayin(c)
}
jishu (i, c shuyu s) {  // i 是字符序号
    dayin(i, c)
}

中文

变量 s = "你好"

计数 (c 属于 s) {       // c 是 rune
    打印(c)
}
计数 (i, c 属于 s) {    // i 是字符序号
    打印(i, c)
}

英文

var s = "你好"

for (c in s) {          // c 是 rune
    print(c)
}
for (i, c in s) {       // i 是字符序号
    print(i, c)
}

逐个处理字符时用遍历，不要用 qu(i) 循环——qu 每次都从头数，整体会很慢。

按字节处理：utf8 视图

写文件、网络协议、调用 C 库这类场景需要字节，用 s.utf8.方法()。参数和返回值都按字节计算，结果是字节（w8 / [w8]，英文 u8 / [u8]），不是字符串。

拼音

bl s = "你好"

dayin(s.changdu())               // 2（字符数）
dayin(s.utf8.changdu())          // 6（字节数）
dayin(s.utf8.qu(0))              // 228
bl bytes = s.utf8.zichuan(0, 3)  // [w8]，'你' 的 3 个字节

jishu (b shuyu s.utf8) {        // b 是 w8
    dayin(b)
}

中文

变量 s = "你好"

打印(s.length())                  // 2（字符数）
打印(s.utf8.length())             // 6（字节数）
打印(s.utf8.at(0))                // 228
变量 bytes = s.utf8.substr(0, 3)  // [u8]，'你' 的 3 个字节

计数 (b 属于 s.utf8) {          // b 是 u8
    打印(b)
}

英文

var s = "你好"

print(s.length())                // 2（字符数）
print(s.utf8.length())           // 6（字节数）
print(s.utf8.at(0))              // 228
var bytes = s.utf8.substr(0, 3)  // [u8]，'你' 的 3 个字节

for (b in s.utf8) {             // b 是 u8
    print(b)
}

字节位置和字符位置不能混用，例如 s.utf8.chazhao(...) 的结果不能直接交给 s.zichuan(...)。

数字与字符串互转

拼音	中文	英文
shuzi_zhuan_zifuchuan	数字_转_字符串	number_to_string
zifuchuan_zhuan_shuzi	字符串_转_数字	string_to_number

拼音

bl s = shuzi_zhuan_zifuchuan(255)      // "255"
bl f = shuzi_zhuan_zifuchuan(0.1)      // "0.1"

changshi {
    bl a = zifuchuan_zhuan_shuzi("42", z32)    // 42
    bl b = zifuchuan_zhuan_shuzi("300", w8)    // 超出 w8 范围，转换失败
} buhuo (e) {
    dayin(e.xinxi)
}

中文

变量 s = 数字_转_字符串(255)           // "255"
变量 f = 数字_转_字符串(0.1)           // "0.1"

尝试 {
    变量 a = 字符串_转_数字("42", i32)         // 42
    变量 b = 字符串_转_数字("300", u8)         // 超出 u8 范围，转换失败
} 捕获 (e) {
    打印(e.msg)
}

英文

var s = number_to_string(255)          // "255"
var f = number_to_string(0.1)          // "0.1"

try {
    var a = string_to_number("42", i32)        // 42
    var b = string_to_number("300", u8)        // 超出 u8 范围，转换失败
} catch (e) {
    print(e.msg)
}

字符串转数字格式严格：不忽略空格、整串都必须是数字，失败时进入 buhuo（捕获 / catch）。