R语言R包详解——stringr包：字符处理

R语言

R语言R包详解——stringr包：字符处理
一切用法皆以说明书为准，想要了解该包，请多查阅说明书或者查看底层算法。

---

---

• stringr是R语言中一个常用的字符串处理包，它提供了一系列函数来处理和操作字符串。
• 常用的字符串的处理以str_开头来命名，方便更直观理解函数的定义，看名知意。
• 掌握此包，辅以正则表达式，足以处理大部分字符处理上的问题。

一、安装与加载R包

install.packages("stringr") # 安装R包
library(stringr) # 加载R包
packageVersion("stringr") # 查看加载的R包版本
help(package = "stringr") # 产看R包的具体信息
1
2
3
4

二、函数简介

三、函数详解

3.1、str_c: 字符串拼接

• 概述：用来进行字符串、向量拼接，与R语言自带的paste和paste0函数功能类似。
• 语法：

str_c(..., sep = "", collapse = NULL)

参数列表：
…: 多参数的输入
sep: 用于字符串拼接，为字符串的分割符。
collapse: 用于向量拼接，为向量字符串的分割符。
1
2
3
4
5
6

• 示例：

> # 默认无向量分割符拼接
> str_c("a","b")
[1] "ab"

> # 指定向量分隔符
> str_c("a","b",sep = "_")
[1] "a_b"

> # 指定向量折叠符
> str_c(c("a","b","c"),collapse = "_")
[1] "a_b_c"

> # 混合应用
> str_c(c("a","b"),c("c","d"),sep = "/",collapse = "_")
[1] "a/c_b/d"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• str_c与paste函数的异同点

> #相同点
> ############
> # 向量拼接字符串，collapse参数的行为一致
> str_c(c("a","b","c"), collapse = "") #collapse 将一个向量的所有元素连接成一个字符串，collapse设置元素间的连接符
[1] "abc"

> paste(c("a","b","c"), collapse = "")
[1] "abc"

> #不同点
> ############
> str_c('a','b') #把多个字符串拼接为一个大的字符串。
[1] "ab"

> paste('a','b') # 多字符串拼接，默认的sep参数行为不一致
[1] "a b"

> #拼接有NA值的字符串向量，对NA的处理行为不一致
> str_c(c("a", NA, "b"), "-d") #若为空，则无法连接
[1] "a-d" NA    "b-d"

> paste(c("a", NA, "b"), "-d") #即使空，也可连接
[1] "a -d"  "NA -d" "b -d" 

> str_c(str_replace_na(c("a", NA, "b")), "-d") #需要进行处理才可连接
[1] "a-d"  "NA-d" "b-d" 
# str_replace_na用于将值NA替换为字符“NA”
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3.2、str_trim: 去掉字符串的空格和TAB(\t)

• 概述：去掉字符串的空格和TAB(\t)
• 语法：

str_trim(string, side = c("both", "left", "right"))

参数列表：
string: 字符串，字符串向量。
side: 过滤方式，both两边都过滤，left左边过滤，right右边过滤
1
2
3
4
5

• 示例：

> # 删除字符串两侧的空格
> str_trim(" a ",side = "both")
[1] "a"

> # 删除字符串左侧的空格
> str_trim(" a ",side = "left")
[1] "a "

> # 删除字符串右侧的空格
> str_trim(" a ",side = "right")
[1] " a"
1
2
3
4
5
6
7
8
9
10
11

3.3、str_pad: 以单字符填充字符串的长度

• 概述：字符补齐函数str_pad，用于在字符串中添加单个字符，可选择添加的位置。
• 语法：

str_pad(string, width, side = c("left", "right", "both"), pad = " ", use_width = TRUE)

参数列表：
string: 字符串，字符串向量
width: 字符串填充后的长度（若指定的width长度小于string长度，则无效扩充）
side: 填充方向，both两边都填充，left左边填充，right右边填充
pad: 用于填充的字符（要求单字符）
use_width: 若为False，则返回string（不扩充）
1
2
3
4
5
6
7
8

• 示例：

> # string ≤ width 无效扩充
> str_pad("aaaaa",3)
[1] "aaaaa"

> # string > width 默认为从左侧扩充
> str_pad("aaaaa",10)
[1] "     aaaaa"

> # 更改扩充方式和填充内容，both方式下，非对称时优先补充至右侧
> str_pad("aaaaa",10,side = "both",pad = "*")
[1] "**aaaaa***"
1
2
3
4
5
6
7
8
9
10
11

3.4、str_dup: 复制字符

• 概述：复制字符串
• 语法：

str_dup(string, times)

参数列表：
string：需要重复处理的字符串
times：指定重复的次数
1
2
3
4
5

• 示例：

> # 字符串复制
> str_dup("a",2)
[1] "aa"

> # 向量复制
> str_dup(c("a","b","c"),1:3)
[1] "a"   "bb"  "ccc"

> # 组合使用
> str_c(c("a","b","c"),str_dup(c(1,2,3),1:3),sep = "_",collapse = "/")
[1] "a_1/b_22/c_333"
1
2
3
4
5
6
7
8
9
10
11

3.5、str_wrap: 控制字符串输出格式

• 概述：用于将长字符串按照指定的宽度进行换行。它可以帮助我们在输出或显示长字符串时，使其更易读和美观。
• 语法：

str_wrap(string, width = 80, indent = 0, exdent = 0, whitespace_only = TRUE))

参数列表：
string: 字符串，字符串向量。
width: 设置一行所占的宽度。
indent: 段落首行的缩进值（缩进字符不纳入width的考量内）。
exdent: 设置第二行及之后每行缩进（缩进字符不纳入width的考量内）。
whitespace_only: 若为Ture则换行只会发生在空格处，若为False则换行也会发生在非字符（,/-等）处。
1
2
3
4
5
6
7
8

• 示例：

> text <- "This is a-long-string that needs to be wrapped to fit within a specified width."

> # 首行不缩进，后面每行缩进两字符（缩进字符不纳入width的考量内）
> str_wrap(text, width = 14,indent = 0,exdent = 2)
[1] "This is\n  a-long-string\n  that needs\n  to be\n  wrapped to\n  fit within\n  a specified\n  width."

> # 缩进会发生在非字符处
> str_wrap(text, width = 14,indent = 0,exdent = 2,whitespace_only = F)
[1] "This is a-\n  long-\n  string that\n  needs to be\n  wrapped to\n  fit within\n  a specified\n  width."
1
2
3
4
5
6
7
8
9

3.6、str_sub: 截取字符串

• 概述：字符过滤函数str_sub和str_subset，str_sub函数通过指定开始和结束位置，过滤出字符串的部分字符串。
• 语法：

str_sub(string, start = 1L, end = -1L)

参数列表：
string: 字符串，字符串向量。
start : 开始位置
end : 结束位置
1
2
3
4
5
6

• 示例：

> # 字符过滤（正向索引）
> str_sub(string = "banana",start = 1,end = 3)
[1] "ban"

> # 字符过滤（反向索引）
> str_sub(string = "banana",start = -2,end = -1)
[1] "na"

> # 字符过滤，并赋值
> x <- "banana"

> str_sub(string = x,start = 1,end = 1) <- "A"

> print(x)
[1] "Aanana"

> # 分2段截取字符串
> str_sub("banana", c(1, 2), c(3, -2)) 
[1] "ban"  "anan"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.7、str_subset: 返回匹配的字符串

• 概述：str_subset函数通过匹配模式，过滤出满足模式的字符串。
• 语法：

str_subset(string, pattern)

参数列表：
string: 字符串，字符串向量。
pattern: 匹配的字符。
1
2
3
4
5

• 示例：

> fruit <- c("apple", "banana", "pear", "pinapple")

> ##返回含字符'ap'的字符串
> str_subset(fruit, "ap") 
[1] "apple"    "pinapple"

> # 运用正则表达式进行详细的字符匹配
> ## 匹配开头
> str_subset(fruit, "^a") 
[1] "apple"

> ## 匹配结尾为a的字符串
> str_subset(fruit, "a$") 
[1] "banana"

> ##返回含'aeiou'任一个字符的单词
> str_subset(fruit, "[aeiou]") 
[1] "apple"    "banana"   "pear"     "pinapple"

> #匹配任意字符，即可以实现丢弃空值
> str_subset(c("a", NA, "b"), ".") 
[1] "a" "b"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.8、word: 从文本中提取单词

• 概述：提取一个完整的字符，不如str_sub和str_subset来得灵活，一些情况下比起前两者来说更加的便捷。
• 语法：

word(string, start = 1L, end = start, sep = fixed(" "))

参数列表：
string: 字符串，字符串向量。
start: 开始的单词。
end: 结束的单词。
sep: 分隔符。
1
2
3
4
5
6
7

• 示例：

> sentences <- c("I saw a cat, it sat down","Maybe you-were-right")

> #提取第二个单词到最后一个单词
> word(sentences, 2, -1) 
[1] "saw a cat, it sat down" "you-were-right"        

> #整个句子从第一~三个单词到最后一个单词
> word(sentences[1], 1:3, -1) 
[1] "I saw a cat, it sat down" "saw a cat, it sat down"   "a cat, it sat down"      

> # 指定分隔符
> word(sentences, 2, -1, sep = ",") 
[1] " it sat down" NA            

> word(sentences, 2, -1, sep = "-") 
[1] NA           "were-right"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3.9、str_count: 字符串计数

• 概述：字符串计数，计算字符串中指定字符的个数
• 语法：

str_count(string, pattern = "")

参数列表：
string: 字符串，字符串向量。
pattern: 匹配的字符。
1
2
3
4
5

• 示例：

> # 单个目标字符计数
> str_count(string = c("sql","json","java"),pattern = "s")
[1] 1 1 0

> # 多个目标字符计数
> str_count(string = c("sql","json","java"),pattern = c("s","j","a"))
[1] 1 1 2

> # 统计字符长度
> str_count(string = c("sql","json","java"))
[1] 3 4 4
1
2
3
4
5
6
7
8
9
10
11

3.10、str_length: 字符串长度

• 概述：计算字符串长度，阉割版str_count函数
• 语法：

str_length(string)

参数列表：
string: 字符串，字符串向量。
1
2
3
4

• 示例：

> str_length(c("I", "am", "福旺旺", NA))
[1]  1  2  3 NA
1
2

3.11、str_sort: 字符串值排序

• 概述：对字符向量进行排序
• 语法：

str_sort(x, decreasing = FALSE, na_last = TRUE, locale = "en", numeric = FALSE,...)

参数列表：
x: 字符串，字符串向量
decreasing: 排序方向
na_last: NA值的存放位置，一共3个值，TRUE放到最后，FALSE放到最前，NA过滤处理
locale: 按哪种语言习惯排序，默认为"en" (English)
numeric: 若为Ture，则将数字当作数值型进行排序处理，否则按照字符型排序处理
1
2
3
4
5
6
7
8

• 示例：

> # 字符向量升序排序，返回字符向量
> str_sort(c("sql","json","python",NA))
[1] "json"   "python" "sql"    NA      

> # 字符向量降序排序，返回字符向量，并丢弃掉NA值
> str_sort(c("sql","json","python",NA),decreasing = TRUE, na_last = NA)
[1] "sql"    "python" "json"  

> # 字符向量升序排序，返回字符向量，并将NA值放在第一个
> str_sort(c("sql","json","python",NA),na_last = F)
[1] NA       "json"   "python" "sql"
1
2
3
4
5
6
7
8
9
10
11

3.12、str_order: 字符串索引排序

• 概述：字符串索引排序，规则同str_sort，str_order和str_sort的区别在于前者返回排序后的索引（下标），后者返回排序后的实际值。
• 语法：

str_order(x, decreasing = FALSE, na_last = TRUE, locale = "en", numeric = FALSE,...)

参数列表：
x: 字符串，字符串向量
decreasing: 排序方向
na_last: NA值的存放位置，一共3个值，TRUE放到最后，FALSE放到最前，NA过滤处理
locale: 按哪种语言习惯排序，默认为"en" (English)
numeric: 若为Ture，则将数字当作数值型进行排序处理，否则按照字符型排序处理
1
2
3
4
5
6
7
8

• 示例：

> # 字符向量升序排序，返回索引向量
> str_order(c("sql","json","python",NA))
[1] 2 3 1 4

> # 字符向量降序排序，返回索引向量，并丢弃掉NA值
> str_order(c("sql","json","python",NA),decreasing = TRUE, na_last = NA)
[1] 1 3 2

> # 字符向量升序排序，返回索引向量，并将NA值放在第一个
> str_order(c("sql","json","python",NA),na_last = F)
[1] 4 2 3 1
1
2
3
4
5
6
7
8
9
10
11

3.13、str_split / str_split_fixed: 字符串分割

• 概述：对字符串进行分割，str_split与str_split_fixed的区别在于前者返回列表格式，后者返回矩阵格式。
• 语法：

str_split(string, pattern, n = Inf, simplify = FALSE)
str_split_fixed(string, pattern, n)

参数列表：
string: 字符串，字符串向量。
pattern: 匹配的字符。
n: 分割个数  #最后一组就不会被分割
simplify: False 返回列表，Ture 返回矩阵（有了这个参数，那str_split_fixed就属于旧时代的遗物了）
1
2
3
4
5
6
7
8

• 示例：

> # 字符分割，返回列表
> str_split(string = "ba-na-na",pattern = "")
[[1]]
[1] "b" "a" "-" "n" "a" "-" "n" "a"

> # 字符分割3次，返回列表
> str_split(string = "ba-na-na",pattern = "", n = 3)
[[1]]
[1] "b"      "a"      "-na-na"

> # 字符分割，返回矩阵
> str_split(string = "ba-na-na",pattern = "-",simplify = T)
     [,1] [,2] [,3]
[1,] "ba" "na" "na"

> # 字符分割，需要指定分割块数
> str_split_fixed(string = "ba-na-na",pattern = "-", n = Inf)
     [,1] [,2] [,3]
[1,] "ba" "na" "na"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.14、str_detect: 检查匹配字符串的字符

• 概述：检查字符串中是否包含指定字符，返回逻辑向量。
• 语法：

str_detect(string, pattern)

参数列表：
string: 字符串，字符串向量。
pattern: 匹配字符。
1
2
3
4
5

• 示例：

> # 检测字符串中是否包含s
> str_detect(string = c("sql","json","java"),pattern = "s")
[1]  TRUE  TRUE FALSE

> # 检测字符串中是否以s开头
> str_detect(string = c("sql","json","java"),pattern = "^s")
[1]  TRUE FALSE FALSE
1
2
3
4
5
6
7

3.15、str_match / str_match_all: 从字符串中提取匹配组

• 概述：与字符提取函数str_extract类似，返回匹配到的字符，不同之处在于返回格式。str_match和str_match_all的区别在于前者返回矩阵格式，后者返回列表格式。str_match_all会返回每一个匹配到的值，str_match只会返回第一个匹配成功的字符。
• 语法：

str_match(string, pattern)
str_match_all(string, pattern)

参数列表：
string: 字符串，字符串向量。
pattern: 匹配字符。
1
2
3
4
5
6

• 示例：

> val <- c("aabbcc", 123, "1ab") 

> # 从字符串中提取匹配组
> # 匹配字符a，并返回对应的字符
> str_match(val, "a") 
     [,1]
[1,] "a" 
[2,] NA  
[3,] "a" 

> #从字符串中提取匹配组，以字符串matrix格式返回
> str_match_all(val, "a") 
[[1]]
     [,1]
[1,] "a" 
[2,] "a" 

[[2]]
     [,1]

[[3]]
     [,1]
[1,] "a" 


> # 匹配字符0-9，限1个，并返回对应的字符
> str_match(val, "[0-9]") 
     [,1]
[1,] NA  
[2,] "1" 
[3,] "1" 

> # 匹配字符0-9，不限数量，并返回对应的字符
> str_match(val, "[0-9]*") 
     [,1] 
[1,] ""   
[2,] "123"
[3,] "1"  

> # 匹配每一个字符0-9，并返回对应的字符
> str_match_all(val, "[0-9]")
[[1]]
     [,1]

[[2]]
     [,1]
[1,] "1" 
[2,] "2" 
[3,] "3" 

[[3]]
     [,1]
[1,] "1" 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

3.16、str_replace / str_replace_all: 字符串替换

• 概述：用于替换字符串中的部分字符，str_replace与str_replace_all的区别在于前者只替换一次匹配的对象，而后者可以替换所有匹配的对象
• 语法：

str_replace(string, pattern, replacement)

参数列表：
string: 字符串，字符串向量。
pattern: 匹配字符。
replacement: 用于替换的字符。
1
2
3
4
5
6

• 示例：

> #替换第一个匹配的字符# 把目标字符串第一个出现的a或b，替换为-
> str_replace(val, "[ab]", "-") 
[1] "-bc" "123" "c-a"

> #替换所有匹配的字符 # 把目标字符串所有出现的a或b，替换为-
> str_replace_all(val, "[ab]", "-") 
[1] "--c" "123" "c--"
1
2
3
4
5
6
7

3.17、str_replace_na:把NA替换为指定字符串

• 概述：把NA替换为指定字符串
• 语法：

str_replace_na(string, replacement = "NA")

参数列表：
string: 字符串，字符串向量。
replacement : 用于替换的字符。
1
2
3
4
5

• 示例：

> # 把NA值替换为字符串
> str_replace_na(c(NA,'NA',"abc"),'x')
[1] "x"   "NA"  "abc"
1
2
3

3.18、str_locate / str_locate_all: 找到匹配的字符串的位置

• 概述：字符位置提取函数str_locate和str_locate_all,返回匹配到的字符的位置，**str_locate()和str_locate_all()**的区别在于前者只匹配第一个匹配的字符，而后者可以匹配所有可能的值
• 语法：

str_locate(string, pattern)
str_locate_all(string, pattern)

参数列表：
string: 字符串，字符串向量。
pattern: 匹配字符。
1
2
3
4
5
6

• 示例：

> val <- c("aabbcc","123","bacabc")

> # 用字符匹配
> str_locate(val, "a")
     start end
[1,]     1   1
[2,]    NA  NA
[3,]     2   2

> # 用向量匹配
> str_locate(val, c("a", 12, "b"))
     start end
[1,]     1   1
[2,]     1   2
[3,]     1   1

> # 以字符串matrix格式返回
> str_locate_all(val, "a")
[[1]]
     start end
[1,]     1   1
[2,]     2   2

[[2]]
     start end

[[3]]
     start end
[1,]     2   2
[2,]     4   4


> # 匹配a或b字符，以字符串matrix格式返回
> str_locate_all(val, "[ab]")
[[1]]
     start end
[1,]     1   1
[2,]     2   2
[3,]     3   3
[4,]     4   4

[[2]]
     start end

[[3]]
     start end
[1,]     1   1
[2,]     2   2
[3,]     4   4
[4,]     5   5
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

3.19、str_extract / str_extract_all: 从字符串中提取匹配字符

• 概述：字符提取函数str_extract和str_extract_all，对字符串进行提取，str_extract_all函数返回所有的匹配结果。
• 语法：

str_extract(string, pattern, group = NULL)
str_extract_all(string, pattern, simplify = FALSE)

参数列表：
string: 字符串，字符串向量。
pattern: 匹配字符。
group: 如果提供，则不会返回完整的匹配，而是从指定的捕获组返回匹配的文本。
simplify: 返回值，TRUE返回matrix，FALSE返回字符串向量
1
2
3
4
5
6
7
8

• 示例：

> shopping_list <- c("apples x4", "bag of flour", "bag of sugar", "milk x2")

> # 提取所有数字，\转义，\d正则表达式，等价于[0-9]查找所有数字。
> str_extract(shopping_list, "\\d")
[1] "4" NA  NA  "2"

> # 提取小写字母，+匹配前面的子表达式一次或多次。
> str_extract(shopping_list, "[a-z]+")
[1] "apples" "bag"    "bag"    "milk"  

> # 提取小写字母，{1,4}匹配前面的子表达式最少1次，最多4次。
> str_extract(shopping_list, "[a-z]{1,4}")
[1] "appl" "bag"  "bag"  "milk"

> # \b匹配一个单词边界，即字与空格间的位置。若左右两侧皆加上\b则表示取一个位于两个空格之间的完整字符串。
> str_extract(shopping_list, "\\b[a-z]{1,4}\\b")
[1] NA     "bag"  "bag"  "milk"

> # ()标记一个子表达式的开始和结束位置。配合group参数，可以精确的挑出想要的子表达式。
> str_extract(shopping_list, "([a-z]+) of ([a-z]+)")
[1] NA             "bag of flour" "bag of sugar" NA            

> str_extract(shopping_list, "([a-z]+) of ([a-z]+)", group = 1)
[1] NA    "bag" "bag" NA   

> str_extract(shopping_list, "([a-z]+) of ([a-z]+)", group = 2)
[1] NA      "flour" "sugar" NA     

> # 提取所有匹配字符，返回列表的形式。
> str_extract_all(shopping_list, "[a-z]+")
[[1]]
[1] "apples" "x"     

[[2]]
[1] "bag"   "of"    "flour"

[[3]]
[1] "bag"   "of"    "sugar"

[[4]]
[1] "milk" "x"   


> str_extract_all(shopping_list, "\\b[a-z]+\\b")
[[1]]
[1] "apples"

[[2]]
[1] "bag"   "of"    "flour"

[[3]]
[1] "bag"   "of"    "sugar"

[[4]]
[1] "milk"


> str_extract_all(shopping_list, "\\d")
[[1]]
[1] "4"

[[2]]
character(0)

[[3]]
character(0)

[[4]]
[1] "2"


> # Simplify参数，将返回值转化为矩阵形式
> str_extract_all(shopping_list, "\\b[a-z]+\\b", simplify = TRUE)
     [,1]     [,2] [,3]   
[1,] "apples" ""   ""     
[2,] "bag"    "of" "flour"
[3,] "bag"    "of" "sugar"
[4,] "milk"   ""   ""     

> str_extract_all(shopping_list, "\\d", simplify = TRUE)
     [,1]
[1,] "4" 
[2,] ""  
[3,] ""  
[4,] "2" 

> # 将所有的单词提取出来（剔除标点之类的非字符）
> str_extract_all("This is, suprisingly, a sentence.", boundary("word"))
[[1]]
[1] "This"        "is"          "suprisingly" "a"           "sentence"  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

3.20、str_conv: 字符编码转换

• 概述：转换字符的编码方式
• 语法：

str_conv(string, encoding)

参数列表：
string: 字符串，字符串向量。
encoding: 编码名。
1
2
3
4
5

• 示例：

> x <- rawToChar(as.raw(177))
> x
[1] "\xb1"
> str_conv(x, "ISO-8859-2") # Polish "a with ogonek"
[1] "ą"
> str_conv(x, "ISO-8859-1") # Plus-minus
[1] "±"
1
2
3
4
5
6
7

3.21、str_to_upper / str_to_lower: 字符串转成大/小写

• 概述：将字符串转成大/小写
• 语法：

str_to_upper(string, locale = "en")
str_to_lower(string, locale = "en")

参数列表：
string: 字符串，字符串向量
locale: 按哪种语言习惯排序，默认为"en" (English)
1
2
3
4
5
6

• 示例：

> val <- "This is a dog. It is so cute."

> # 全大写
> str_to_upper(val)
[1] "THIS IS A DOG. IT IS SO CUTE."

> # 全小写
> str_to_lower(val)
[1] "this is a dog. it is so cute."
1
2
3
4
5
6
7
8
9

3.22、str_to_title: 字符串转成标题

• 概述：将每个单词的首字母都大写
• 语法：

str_to_title(string, locale = "en")

参数列表：
string: 字符串，字符串向量
locale: 按哪种语言习惯排序，默认为"en" (English)
1
2
3
4
5

• 示例：

> val <- "This is a dog. It is so cute."

> # 每个单词的首字母都大写
> str_to_title(val)
[1] "This Is A Dog. It Is So Cute."
1
2
3
4
5

3.23、str_to_sentence：字符转为语句

• 概述：只有第一个单词的首字母大写
• 语法：

str_to_sentence(string, locale = "en")

参数列表：
string: 字符串，字符串向量
locale: 按哪种语言习惯排序，默认为"en" (English)
1
2
3
4
5

• 示例：

> val <- "This is a dog. It is so cute."

> # 只有第一个单词的首字母大写
> str_to_sentence(val)
[1] "This is a dog. It is so cute."
1
2
3
4
5

3.24、str_glue / str_glue_data：提取字符串中的变量

• 概述：字符串格式化函数str_glue，用花括号{}表示占位符，括号内的变量被替换成全局变量值。str_glue 与 str_glue_data的区别在于参数传递方式和变量引用方式有所不同。如果需要从数据框中获取变量值，可以使用str_glue_data函数，而如果直接引用变量名，可以使用str_glue函数。
  • 这两个函数的区别具体如下：

1. 参数传递方式：str_glue函数使用…参数来传递变量，而str_glue_data函数使用data参数来传递变量。在str_glue_data中，可以通过data参数指定一个数据框（data frame），其中包含了要插入到字符串中的变量。

2. 变量引用方式：在str_glue函数中，可以直接引用变量名，例如"{var}“。而在str_glue_data函数中，需要使用花括号和句点的组合来引用变量，例如”{.data$var}"。这是因为str_glue_data需要通过data参数指定数据框，所以需要使用句点来引用数据框中的变量。

3. 环境设置：str_glue函数默认使用当前环境来获取变量值，而str_glue_data函数使用data参数指定的数据框作为环境来获取变量值。这意味着在str_glue_data中，可以直接使用数据框中的变量名，而不需要在变量名前加上数据框的名称。

• 语法：

str_glue(..., .sep = "", .envir = parent.frame())
str_glue_data(.x, ..., .sep = "", .envir = parent.frame(), .na = "NA")

参数列表：
...：表示要插入到字符串中的变量。可以是一个或多个变量，用逗号分隔。
.sep：表示多个变量之间的分隔符，默认为空格。例如，如果设置为"-"，则多个变量之间将用"-"分隔。
.envir：表示要从中获取变量值的环境，默认为当前环境。可以是一个环境对象或一个整数，表示要获取变量值的环境的层数。
.na：表示当变量值为NA时的替代文本，默认为空字符串。例如，如果设置为"NA"，则当变量值为NA时，将使用"NA"替代。
1
2
3
4
5
6
7
8

• 示例：

> name <- "Fred"
> age <- 50
> anniversary <- as.Date("1991-10-12")

> # 使用全局变量
> str_glue(
+   "My name is {name}, ",
+   "my age next year is {age + 1}, ",
+   "and my anniversary is {format(anniversary, '%A, %B %d, % ..." ... [TRUNCATED] 
My name is Fred, my age next year is 51, and my anniversary is 星期六, 十月 12, 1991.

> # 双{{}}会失效
> str_glue("My name is {name}, not {{name}}.")
My name is Fred, not {name}.

> # 使用局部变量
> str_glue(
+   "My name is {name}, ",
+   "and my age next year is {age + 1}.",
+   name = "Joe",
+   age = 40
+ )
My name is Joe, and my age next year is 41.

> # 调用数据框
> mtcars %>% str_glue_data("{rownames(.)} has {hp} hp")
Mazda RX4 has 110 hp
Mazda RX4 Wag has 110 hp
Datsun 710 has 93 hp
Hornet 4 Drive has 110 hp
Hornet Sportabout has 175 hp
Valiant has 105 hp
...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

3.25、str_remove / str_remove_all: 字符删除

• 概述：字符删除函数str_remove和str_remove_all，用于删除字符串中的部分字符。
• 语法：

str_remove(string, pattern)
str_remove_all(string, pattern)

参数列表：
string: 字符串，字符串向量。
pattern: 匹配字符。
1
2
3
4
5
6

• 示例：

> # 删除第一个匹配到的字符
> str_remove(string = c("abc","123","bac"),pattern = "[ab]")
[1] "bc"  "123" "ac" 

> # 删除所有匹配到的字符
> str_remove_all(string = c("abc","123","bac"),pattern = "[ab]")
[1] "c"   "123" "c" 
1
2
3
4
5
6
7

四、参数控制函数

• 概述：参数控制函数，仅用于构造功能的参数，不能独立使用。
• boundary: 定义使用边界
• coll: 使用标准Unicode排序规则比较字符串
• fixed: 比较文字字节
• regex: 定义正则表达式

4.1、boundary: 定义使用边界

• 概述：定义使用边界
• 语法：

boundary(
  type = c("character", "line_break", "sentence", "word"),
  skip_word_none = NA,
  ...
)

参数列表：
type: 要检测的边界类型

character
每一个字符
line_break
换行符
sentence
一句话（以"."结尾，且句子前后有空格分开）
word
单词（前后有空格隔开）

skip_word_none: 忽略不包含任何字符或数字的“单词”一一例如标点符号。默认NA仅在单词边界上拆分时才会跳过此类“单词”。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 示例：

> words <- c("These are   some words.")
> str_count(words, boundary("word"))
[1] 4
> str_split(words, " ")[[1]]
[1] "These"  "are"    ""       ""       "some"   "words."
> str_split(words, " ")
[[1]]
[1] "These"  "are"    ""       ""       "some"   "words."

> str_split(words, boundary("word"))[[1]]
[1] "These" "are"   "some"  "words"
1
2
3
4
5
6
7
8
9
10
11

4.2、coll: 使用标准Unicode排序规则比较字符串。

• 概述：使用标准Unicode排序规则比较字符串
• 语法：

coll(pattern, ignore_case = FALSE, locale = "en", ...)

参数列表：
pattern: 匹配字符
ignore_case: Ture不区分大小写差异，False区分差异
locale: 按哪种语言习惯排序，默认为"en" (English)
1
2
3
4
5
6

• 示例：

> pattern <- "a.b"
> strings <- c("abb", "a.b")
> str_detect(strings, pattern)
[1] TRUE TRUE
> str_detect(strings, fixed(pattern))
[1] FALSE  TRUE
> str_detect(strings, coll(pattern))
[1] FALSE  TRUE
> 
> # coll() is useful for locale-aware case-insensitive matching
> i <- c("I", "\u0130", "i")
> i
[1] "I" "İ" "i"
> str_detect(i, fixed("i", TRUE))
[1]  TRUE FALSE  TRUE
> str_detect(i, fixed("i", FALSE))
[1] FALSE FALSE  TRUE
> str_detect(i, coll("i", TRUE))
[1]  TRUE FALSE  TRUE
> str_detect(i, coll("i", TRUE, locale = "tr"))
[1] FALSE  TRUE  TRUE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4.3、fixed: 比较文字字节

• 概述：比较文字字节
• 语法：

fixed(pattern, ignore_case = FALSE)

参数列表：
pattern: 匹配字符
ignore_case: Ture不区分大小写差异，False区分差异
1
2
3
4
5

• 示例：

> pattern <- "a.b"
> strings <- c("abb", "a.b")
> str_detect(strings, pattern)
[1] TRUE TRUE
> str_detect(strings, fixed(pattern))
[1] FALSE  TRUE
> str_detect(strings, coll(pattern))
[1] FALSE  TRUE
> 
> # coll() is useful for locale-aware case-insensitive matching
> i <- c("I", "\u0130", "i")
> i
[1] "I" "İ" "i"
> str_detect(i, fixed("i", TRUE))
[1]  TRUE FALSE  TRUE
> str_detect(i, fixed("i", FALSE))
[1] FALSE FALSE  TRUE
> str_detect(i, coll("i", TRUE))
[1]  TRUE FALSE  TRUE
> str_detect(i, coll("i", TRUE, locale = "tr"))
[1] FALSE  TRUE  TRUE
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4.4、coll和fixed区别

在R语言的stringr包中，coll和fixed函数都是用于进行字符串匹配和替换的函数，但它们有一些区别。

1. coll函数：coll函数用于进行基于正则表达式的字符串匹配和替换。它使用的是基于Unicode的正则表达式引擎，可以进行更复杂的模式匹配。coll函数可以接受正则表达式作为模式参数，并根据模式进行字符串的匹配和替换。

2. fixed函数：fixed函数用于进行基于固定字符串的字符串匹配和替换。它不使用正则表达式，而是直接按照给定的固定字符串进行匹配和替换。fixed函数适用于简单的字符串匹配，不需要考虑正则表达式的特殊字符。

总的来说，coll函数适用于复杂的字符串匹配和替换，可以使用正则表达式进行模式匹配。而fixed函数适用于简单的字符串匹配和替换，不需要考虑正则表达式的特殊字符。选择使用哪个函数取决于具体的需求和字符串处理的复杂程度。

4.5、regex: 定义正则表达式

• 概述：定义正则表达式
• 语法：

regex(
  pattern,
  ignore_case = FALSE,
  multiline = FALSE,
  comments = FALSE,
  dotall = FALSE,
  ...
)

参数列表：
pattern: 匹配字符
ignore_case: Ture不区分大小写差异，False区分差异
multiline: 如果TRUE，则$和^匹配每一行的开头和结尾。如果为FALSE(默认)，则只匹配输入的开始和结束
comments: 如果为TRUE，则忽略空格和以#开头的注释。用\\转义文本空间
dotall: 如果为TRUE，将匹配行终止符（将换行符\n当作是一般字符去识别）。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 示例：

> # Regular expression variations
> str_extract_all("The Cat in the Hat", "[a-z]+")
[[1]]
[1] "he"  "at"  "in"  "the" "at" 


> # ignore_case = Ture 忽视大小写
> str_extract_all("The Cat in the Hat", regex("[a-z]+", TRUE))
[[1]]
[1] "The" "Cat" "in"  "the" "Hat"


> # multiline = TRUE 匹配每一行
> str_extract_all("a\nb\nc", "^.")
[[1]]
[1] "a"


> str_extract_all("a\nb\nc", regex("^.", multiline = TRUE))
[[1]]
[1] "a" "b" "c"


> # dotall = TRUE 匹配换行符
> str_extract_all("a\nb\nc", "a.")
[[1]]
character(0)


> str_extract_all("a\nb\nc", regex("a.", dotall = TRUE))
[[1]]
[1] "a\n"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

五、用于字符处理的其他包

除了stringr包之外，R语言中还有其他一些常用的用于字符处理的包，包括：

1. stringi：stringi包是一个功能强大的字符串处理包，提供了大量的函数和方法来处理和操作字符串。它支持多种语言和字符编码，具有较高的性能。

2. stringdist：stringdist包提供了一系列计算字符串之间距离的函数，例如编辑距离、汉明距离等。它可以用于字符串匹配、聚类和分类等任务。

3. stringi：stringi包是另一个用于字符串处理的包，它提供了一系列函数来处理和操作字符串，包括字符串匹配、替换、分割、提取等功能。

4. string：string包提供了一些基本的字符串处理函数，例如字符串匹配、替换、分割等。它是R语言的基础包，无需额外安装。

5. stringdistroy：stringdistroy包是stringdist包的扩展，提供了更多的字符串距离计算方法，例如Jaro-Winkler距离、Smith-Waterman距离等。

这些包都提供了丰富的函数和方法来处理和操作字符串，具体选择哪个包取决于您的需求和偏好。您可以通过在R中使用install.packages()命令安装这些包，并使用library()命令加载它们。同时，您也可以通过使用?命令在R中获取更详细的帮助信息。