Julia 字符串-Julia入门教程

当前位置:　首页>> 技术小册>> Julia入门教程

字符串（英语：string），是由零个或多个字符组成的有限序列。它是编程语言中表示文本的数据类型。

Julia 通常使用单引号 ' 创建单个字符，双引号 " 或三个引号 """ 创建字符串。例如：

```
c = 'x'

str = "maxiaoke"

maxiaoke = """码小课 "maxiaoke"，包含了单个引号"""
```

###Julia 字符串类型特性：

Julia 中用于字符串（和字符串字面量）的内置具体类型是 String。
Julia 的字符串类型都是抽象类型 AbstractString 的子类型。
Julia 有优秀的表示单字符的类型，即 AbstractChar。Char 是 AbstractChar 的内置子类型，它能表示任何 Unicode 字符的 32 位原始类型（基于 UTF-8 编码）。
Julia 字符串是不可更改的——任何 AbstractString 对象的值不可改变。

###字符
单个字符用 Char 值表示。

Char 是 32 位原始类型，可以转换为其对应的整数值，即 Unicode 代码：

实例
```
julia> c = 'x'
'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)

julia> typeof(c)
Char

julia> c = Int('x')
120

julia> typeof(c)
Int64
```
我们也可以将一个整数值转换为 Char：

实例
```
julia> Char(97)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> Char(120)
'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)
```
我们可以对 Char 的值进行比较和有限的算术运算：

实例
```
julia> 'A' < 'a'
true

julia> 'A' <= 'a' <= 'Z'
false

julia> 'A' <= 'X' <= 'Z'
true

julia> 'x' - 'a'
23

julia> 'A' + 1
'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)
```
###字符串
Julia 中的字符串可以使用双引号 " 或三个双引号 """ 来声明，如果您需要在字符串中的某个部分使用引号，就可以使用三个双引号来执行此操作，如下所示：

实例
```
julia> str = "maxiaoke"
"maxiaoke"

julia> maxiaoke = """码小课 "maxiaoke"，包含了单个引号"""
"码小课 \"maxiaoke\"，包含了单个引号"
```
如果字符串太长了，我们可以使用反斜杠 \ 来拆分：

实例
```
julia> "This is a long \
       line"
"This is a long line"
```
Julia 字符串也可以跟数组一样使用索引来读取指定位置的字符或者截取指定位置的字符串，索引的起时位置为 1 或者 begin，结束位置为 end ：
实例
```
julia> str = "maxiaoke"
"maxiaoke"

julia> str[begin]
'R': ASCII/Unicode U+0052 (category Lu: Letter, uppercase)

julia> str[1]
'R': ASCII/Unicode U+0052 (category Lu: Letter, uppercase)

julia> str[2]
'U': ASCII/Unicode U+0055 (category Lu: Letter, uppercase)

julia> str[end]
'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)

julia> str[end-1]
'O': ASCII/Unicode U+004F (category Lu: Letter, uppercase)
```
我们可以用范围索引来提取子字符串：

实例
```
julia> str = "maxiaoke"
"maxiaoke"

julia> str[begin:end]
"maxiaoke"

julia> str[begin:end-1]
"RUNOO"

julia> str[2:5]
"UNOO"
```
另外，表达式 str[k] 和 str[k:k] 给出的结果是不同的，前者是通过索引获取指定位置的字符，类型是 Char 类型，后者是通过给定的范围读取字符串，只不过它只是包含了一个字符的字符串：

实例
```
julia> str[6]
'B': ASCII/Unicode U+0042 (category Lu: Letter, uppercase)

julia> str[6:6]
"B"
```
范围截取也可以使用 SubString 方法来实现， 例如：

实例
```
julia> str = "long string"
"long string"

julia> substr = SubString(str, 1, 4)
"long"

julia> typeof(substr)
SubString{String}
```
###字符串拼接
我们可以使用 string() 方法将多个字符串拼接起来：
实例
```
julia> greet = "Hello"
"Hello"

julia> whom = "world"
"world"

julia> string(greet, ", ", whom, ".\n")
"Hello, world.\n"
```
###插值
拼接构造字符串的方式有时有些麻烦。为了减少对于 string 的冗余调用或者重复地做乘法，Julia 允许像 Perl 中一样使用 $ 对字符串字面量进行插值：

实例
```
julia> "$greet, $whom.\n"
"Hello, world.\n"
```
这更易读更方便，而且等效于上面的字符串拼接——系统把这个显然一行的字符串字面量重写成带参数的字符串字面量拼接 string(greet, ", ", whom, ".\n")。

在 $ 之后最短的完整表达式被视为插入其值于字符串中的表达式。因此，你可以用括号向字符串中插入任何表达式：

实例
```
julia> "1 + 2 = $(1 + 2)"
"1 + 2 = 3"
```
拼接和插值都调用 string 以转换对象为字符串形式。 然而，string 实际上仅仅返回了 print 的输出，因此，新的类型应该添加 print 或 show 方法，而不是 string 方法。

多数非 AbstractString 对象被转换为和它们作为文本表达式输入的方式密切对应的字符串：

实例
```
julia> v = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> "v: $v"
"v: [1, 2, 3]"
```
string 是 AbstractString 和 AbstractChar 值的标识，所以它们作为自身被插入字符串，无需引用，无需转义：

实例
```
julia> c = 'x'
'x': ASCII/Unicode U+0078 (category Ll: Letter, lowercase)

julia> "hi, $c"
"hi, x"
```
若要在字符串字面量中包含文本 $，就用反斜杠转义：

实例
```
julia> print("I have \$100 in my account.\n")
I have $100 in my account.
```
###Unicode 和 UTF-8
Julia 完全支持 Unicode 字符和字符串。

在字符字面量中，Unicode 代码可以用 Unicode \u 和 \U 转义序列表示，也可以用所有标准 C 转义序列表示。这些同样可以用来写字符串字面量：

实例
```
julia> s = "\u2200 x \u2203 y"
"∀ x ∃ y"
```
这些 Unicode 字符是作为转义还是特殊字符显示，取决于你终端的语言环境设置以及它对 Unicode 的支持。字符串字面量用 UTF-8 编码。UTF-8 是一种可变长度的编码，也就是说并非所有字符都以相同的字节数（code units）编码。在 UTF-8 中，ASCII 字符（小于 0x80(128) 的那些）如它们在 ASCII 中一样使用单字节编码；而 0x80 及以上的字符使用最多 4 个字节编码。

###三引号字符串字面量
三引号 """...""" 为我们创建更长更复杂的字符串提供了便利，三引号内部可以方便的使用换行、引号及缩进等，不需要特别处理。

实例
```
julia> str = """
           Hello,
           world.
         """
"  Hello,\n  world.\n"
```
###字符串比较
我们可以使用比较操作符按照字典顺序比较字符串：

实例
```
julia> "abracadabra" < "xylophone"
true

julia> "abracadabra" == "xylophone"
false

julia> "Hello, world." != "Goodbye, world."
true

julia> "1 + 2 = 3" == "1 + 2 = $(1 + 2)"
true
```
你可以使用 findfirst 与 findlast 函数搜索特定字符的索引：

实例
```
julia> findfirst(isequal('o'), "xylophone")
4

julia> findlast(isequal('o'), "xylophone")
7

julia> findfirst(isequal('z'), "xylophone")
```
你可以带上第三个参数，用 findnext 与 findprev 函数来在给定偏移量处搜索字符：

实例
```
julia> findnext(isequal('o'), "xylophone", 1)
4

julia> findnext(isequal('o'), "xylophone", 5)
7

julia> findprev(isequal('o'), "xylophone", 5)
4

julia> findnext(isequal('o'), "xylophone", 8)
```
你可以用 occursin 函数检查在字符串中某子字符串可否找到。

实例
```
julia> occursin("world", "Hello, world.")
true

julia> occursin("o", "Xylophon")
true

julia> occursin("a", "Xylophon")
false

julia> occursin('o', "Xylophon")
true
```
最后那个例子表明 occursin 也可用于搜寻字符字面量。

另外还有两个方便的字符串函数 repeat 和 join：

实例
```
julia> repeat(".:Z:.", 10)
".:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:..:Z:."

julia> join(["apples", "bananas", "pineapples"], ", ", " and ")
"apples, bananas and pineapples"
```
其它有用的函数还包括：
```
firstindex(str) - 给出可用来索引到 str 的最小（字节）索引（对字符串来说这总是 1，对于别的容器来说却不一定如此）。
lastindex(str) - 给出可用来索引到 str 的最大（字节）索引。
length(str) - str 中的字符个数。
length(str, i, j) - str 中从 i 到 j 的有效字符索引个数。
ncodeunits(str) - 字符串中代码单元（码元）的数目。
codeunit(str, i) - 给出在字符串 str 中索引为 i 的代码单元值。
thisind(str, i) - 给定一个字符串的任意索引，查找索引点所在的首个索引。
nextind(str, i, n=1) - 查找在索引 i 之后第 n 个字符的开头。
prevind(str, i, n=1) - 查找在索引 i 之前第 n 个字符的开始。
```
###原始字符串字面量
无插值和非转义的原始字符串可用 raw"..." 形式的非标准字符串字面量表示。原始字符串字面量生成普通的 String 对象，它无需插值和非转义地包含和输入完全一样的封闭式内容。这对于包含其他语言中使用 " 或 \" 作为特殊字符的代码或标记的字符串很有用。

例外的是，引号仍必须转义，例如 raw"\"" 等效于 "\""。为了能够表达所有字符串，反斜杠也必须转义，不过只是当它刚好出现在引号前面时。
```
julia> println(raw"\\ \\\"")
\\ \"
```
请注意，前两个反斜杠在输出中逐字显示，这是因为它们不是在引号前面。然而，接下来的一个反斜杠字符转义了后面的一个反斜杠；又由于这些反斜杠出现在引号前面，最后一个反斜杠转义了一个引号。

该分类下的相关小册推荐：

暂无相关推荐.