字符串函数一般都是向量化的，对输入的字符串向量的每个元素进行操作。

字符串基础

readLines()

  1. 在R中读入一个文本文件可以用readLines()函数，它返回一个字符型向量，文件中每一行都是向量中对应的一个元素。这个文件可以是本地文件，也可以是一个网址。
index <- readLines("https://www.baidu.com") # 我的主页
#> Warning in readLines("https://www.baidu.com"): incomplete final line found on
#> 'https://www.baidu.com'
head(index) # HTML代码
#> [1] "<html>"                                                                
#> [2] "<head>"                                                                
#> [3] "\t<script>"                                                            
#> [4] "\t\tlocation.replace(location.href.replace(\"https://\",\"http://\"));"
#> [5] "\t</script>"                                                           
#> [6] "</head>"
  1. readline()支持从键盘直接输入一行文本，显然，R必须在交互式模式下运行，否则人没法输入任何东西。它有一个常用的地方，就是在代码运行过程中要求用户输入一些回答，例如：
x <- readline("Answer yes or no: ")

当R运行到这一行时会停下来等待用户输入（回车表示输入结束），然后根据输入的结果，代码可以接着执行。

  1. 在Windows系统中，readLines()读utf-8编码的txt文件会导致乱码，只能顺利读取ANSI编码的txt文件。

writeLines()

  1. 注意，字符串的打印形式与其本身的内容不是相同的，因为打印形式中会显示出转义字符。如果想要查看字符串的真正内容，可以使用writeLines()

writeLines(text, con = stdout(), sep = “”, useBytes = FALSE)

  1. Windows系统中writeLines()写入txt文件会导致乱码，替代方案是用writeBin(charToRaw(string), file)写入文件

字符串包含引文时引号的使用

若一个字符串包含引文，为了符合行文习惯(双引号)，并使代码引号有层次的区别，外层应用单引号。

# string1 <- 'When putting a 'quote' inside a string, use single quotation marks.'
# string1 <- "When putting a "quote" inside a string, use double quotation marks."
string3 <- "When putting a 'quote' inside a string, use single quotation marks inside and double quotation marks outside."
string4 <- 'When putting a "quote" inside a string, use double quotation marks inside and single quotation marks outside.'

# 字符串的打印形式
string3
string4
#> [1] "When putting a 'quote' inside a string, use single quotation marks inside and double quotation marks outside."
#> [1] "When putting a \"quote\" inside a string, use double quotation marks inside and single quotation marks outside."
# 字符串编译后导出的形式
writeLines(string3)
writeLines(string4)
#> When putting a 'quote' inside a string, use single quotation marks inside and double quotation marks outside.
#> When putting a "quote" inside a string, use double quotation marks inside and single quotation marks outside.

string1和string2有语法错误，前后两个字符串中间夹了一个编译器不认识的quote。

string3和string4在语法上没问题，但编译时效果不同。string4才是我们想要的。

转义符号”\”

反斜杠”\“可以将R语言及R Markdown的语法部件转义为字符。
如果想要在字符串中包含一个单引号或双引号，可以使用”\’“和”\““对其进行转义。

string5 <- 'I don\'t know why they called us "Chinese".'
string6 <- "When putting a \"quote\" inside a string, you can use backslash as well."
writeLines(string5)
writeLines(string6)
#> I don't know why they called us "Chinese".
#> When putting a "quote" inside a string, you can use backslash as well.

如果想要在字符串中包含一个反斜杠，就需要使用两个反斜杠：“\\”

string7 <- "I think the backslash \"\\\" is amazing!"
print(string7) # 或 string7
writeLines(string7)
#> [1] "I think the backslash \"\\\" is amazing!"
#> I think the backslash "\" is amazing!

特殊字符

其他几种特殊字符。最常用的是换行符”\n”、制表符”\t”和退格”\b”，你可以使用 ?‘“’ 或 ?”’” 调出帮助文件来查看完整的特殊字符列表。

string8 <- 'The special characters "\n", "\t" and "\b" are very interesing.'
string9 <- "The special characters \"\\n\", \"\\t\" and \"\\b\" are very interesing."
writeLines(string8)
writeLines(string9)
#> The special characters "
#> ", " " and "" are very interesing.
#> The special characters "\n", "\t" and "\b" are very interesing.

生成的html文件中”\b”变成了一个奇怪的方框，控制台显示的则是正确的。可能R Markdown与R语言中”\b”的含义不同。

字符串格式化

base::sprintf()

sprintf(包含占位符的字符串，欲填充的字符串)

占位符
% 如果要在占位符内部使用%，需要写成%%
转换符 类型
d 十进制整数
o 八进制整数
x, X 小/大写十六进制整数
f 十进制浮点数
e, E 科学计数法表示的数，e小写或大写
g, G 智能选择使用浮点数还是科学计数法（g对应e，G对应E），默认显示6位有效数字
s 字符串
浮点数格式
width.precision 输出的最小宽度（不足以空格补齐）.输出精度（对f和e/E意味着小数点后几位，对g/G意味着有效数字位数）
- 指定左对齐（默认右对齐），即宽度不足时从右边补充空格
+ 永远带符号（默认只有负数带一个负号，正数不带符号）
空格 首字符并非负号时，空一格
0 宽度不足时补0，而非默认的空格 
sprintf("The ratio is %d%%", 10)
#> [1] "The ratio is 10%"
sprintf("%f", pi) # 浮点数
#> [1] "3.141593"
sprintf("%.3f", pi) # 保留小数点后3位
#> [1] "3.142"
sprintf("%.0f", pi) # 保留小数点后0位
#> [1] "3"
sprintf("%5.1f", pi) # 最小宽度为5，保留小数点后1位，不足补空格
#> [1] "  3.1"
sprintf("%05.1f", pi) # 用0补齐
#> [1] "003.1"
sprintf("%+f", pi) # 永远带符号
#> [1] "+3.141593"
sprintf("% f", pi)
#> [1] " 3.141593"
sprintf("%-10f", pi) # 左对齐，宽度为10
#> [1] "3.141593  "
sprintf("%e", pi)
#> [1] "3.141593e+00"
sprintf("%E", pi)
#> [1] "3.141593E+00"
sprintf("%g", pi)
#> [1] "3.14159"
sprintf("%g", 1e6 * pi)
#> [1] "3.14159e+06"
sprintf("%.9g", 1e6 * pi)
#> [1] "3141592.65"
sprintf("%.2g", 23.75)
#> [1] "24"
sprintf(
  "min 10-char string '%10s'",
  c("a", "ABC", "and an even longer one")
)
#> [1] "min 10-char string '         a'"            
#> [2] "min 10-char string '       ABC'"            
#> [3] "min 10-char string 'and an even longer one'"

借助 python

加入 python 代码块，使用 python 中的字符串格式化方法 .format()

模板字符串.format(以逗号分隔的填充参数序列)

其中，{}为模板中的槽，槽内部定义每个槽的格式化样式，形如：

id:[fill][align][sign][width][,][.precision][type]

类别 含义
fill 宽度不足时填充的字符
align 对齐方式. < 左对齐；> 右对齐；= 内容右对齐，符号放置在填充字符（如”0”）的左侧；^ 居中
sign

+ 正数加+，负数加-

空格，正数加空格，负数加-
, 为数字添加千位分隔符
width 输出的最小宽度（不足以 fill 补齐）
.precision 小数点后保留精度
type 格式化类型
s 字符串（不指定type时默认）
d 十进制整数
o 八进制整数
x, X 小/大写十六进制整数
f 十进制浮点数
e, E 科学计数法表示的数，e小写或大写
g, G 智能选择使用浮点数还是科学计数法（g对应e，G对应E），默认显示6位有效数字
% 百分比，默认显示小数点后6位
b 二进制整数
c 10进制整数转换为 Unicode 字符

这种方法的缺点在于，输出宽度、精度等参数必须是确定的常数，而不能是变量。因此当这些数值必须取变量时，仍要使用.rjust()、.ljust()和.center()方法。

示例：

str1 = "{0:=^20}".format("Python") 
str1 # 用 '=' 填充，居中对齐，槽宽度为20
#> '=======Python======='
str2 = "{:=^20}".format("Python") 
str2 # 参数索引0可以省略
#> '=======Python======='
str3 = "{:*>20}".format("BIT") 
str3 # 用 '*' 填充，右对齐，槽宽度为20
#> '*****************BIT'
str4 = "{:10}".format("BIT")
str4 # 默认左对齐，空格填充
#> 'BIT       '
str5 = "{:,.2f}".format(12345.6789)
str5 # 使用千位分隔符，保留两位小数的浮点型
#> '12,345.68'
str6 = "{0:b}, {0:c}, {0:d}, {0:o}, {0:x}, {0:X}".format(426)
str6 # 一个参数填到所有槽中，分别转换为：二进制，Unicode 编码，十进制，八进制，十六进制，大写的十六进制
#> '110101010, ƪ, 426, 652, 1aa, 1AA'
str7 = "{0:.2e}, {0:.2E}, {0:.2f}, {0:.2%}".format(3.14)
str7 # 分别转换为：科学记数法，大写科学记数法，浮点数，百分数
#> '3.14e+00, 3.14E+00, 3.14, 314.00%'
str8  = "I am {:s}, age {:d}, money {:.2f}".format("seven", 18, 88888.1)
str8 # 槽与填充参数的顺序恰好对应时，也可以省略参数索引
#> 'I am seven, age 18, money 88888.10'

formattable 包

  • percent()
  • comma()
  • currency()
  • accounting()，会计格式，如负数用括号表示
  • scientific()
library(formattable)

df <-
  data.frame(
    id = 1:10,
    name = c(
      "Bob",
      "Ashley",
      "James",
      "David",
      "Jenny",
      "Hans",
      "Leo",
      "John",
      "Emily",
      "Lee"
    ),
    age = c(28, 27, 30, 28, 29, 29, 27, 27, 31, 30),
    grade = c("C", "A", "A", "C", "B", "B", "B", "A", "C", "C"),
    test1_score = c(8.9, 9.5, 9.6, 8.9, 9.1, 9.3, 9.3, 9.9, 8.5, 8.6),
    test2_score = c(9.1, 9.1, 9.2, 9.1, 8.9, 8.5, 9.2, 9.3, 9.1, 8.8),
    final_score = c(9, 9.3, 9.4, 9, 9, 8.9, 9.25, 9.6, 8.8, 8.7),
    registered = c(TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE),
    stringsAsFactors = FALSE
  )
df
#>    id   name age grade test1_score test2_score final_score registered
#> 1   1    Bob  28     C         8.9         9.1        9.00       TRUE
#> 2   2 Ashley  27     A         9.5         9.1        9.30      FALSE
#> 3   3  James  30     A         9.6         9.2        9.40       TRUE
#> 4   4  David  28     C         8.9         9.1        9.00      FALSE
#> 5   5  Jenny  29     B         9.1         8.9        9.00       TRUE
#> 6   6   Hans  29     B         9.3         8.5        8.90       TRUE
#> 7   7    Leo  27     B         9.3         9.2        9.25       TRUE
#> 8   8   John  27     A         9.9         9.3        9.60      FALSE
#> 9   9  Emily  31     C         8.5         9.1        8.80      FALSE
#> 10 10    Lee  30     C         8.6         8.8        8.70      FALSE
formattable(
  df,
  list(
    age = color_tile("white", "orange"),
    grade = formatter("span", style = x ~ ifelse(
      x == "A", style(color = "green", font.weight = "bold"), NA
    )),
    area(col = c(test1_score, test2_score)) ~ normalize_bar("pink", 0.2),
    final_score = formatter(
      "span",
      style = x ~ style(color = ifelse(rank(-x) <= 3, "green", "gray")),
      x ~ sprintf("%.2f (rank: %02d)", x, rank(-x))
    ),
    registered = formatter(
      "span",
      style = x ~ style(color = ifelse(x, "green", "red")),
      x ~ icontext(ifelse(x, "ok", "remove"), ifelse(x, "Yes", "No"))
    )
  )
)
id name age grade test1_score test2_score final_score registered
1 Bob 28 C 8.9 9.1 9.00 (rank: 06) Yes
2 Ashley 27 A 9.5 9.1 9.30 (rank: 03) No
3 James 30 A 9.6 9.2 9.40 (rank: 02) Yes
4 David 28 C 8.9 9.1 9.00 (rank: 06) No
5 Jenny 29 B 9.1 8.9 9.00 (rank: 06) Yes
6 Hans 29 B 9.3 8.5 8.90 (rank: 08) Yes
7 Leo 27 B 9.3 9.2 9.25 (rank: 04) Yes
8 John 27 A 9.9 9.3 9.60 (rank: 01) No
9 Emily 31 C 8.5 9.1 8.80 (rank: 09) No
10 Lee 30 C 8.6 8.8 8.70 (rank: 10) No

文字格式自定义、文字背景自定义、文本自定义三种自定义可视化类型：

  • color_tile函数用于输出按照数值量级进行颜色背景填充的列。
  • formatter函数提供字体显示格式的自定义，grade列自定义了值为A的记录显示绿色，并将字体加粗，否则忽略。
  • test1_score, test2_score两列通过area函数在对应字体背景位置使用条形图来代表指标量级大小，颜色填充粉色。
  • final_score列对指标按照top3显示绿色，其余显示灰色，同时将内容显示格式自定义为浮点型+(rank:名次)进行显示。
  • registered列则在对填充颜色按照对应布尔值进行显示（TRUE显示绿色、FALSE显示红色）之外，在左侧添加了对用的icon文本（TRUE显示绿色对号，FALSE显示红色叉号）。

函数分类

字符串拼接函数

  • str_c: 字符串拼接。
  • str_trim: 去掉字符串的白空格
  • str_pad: 补充字符串的长度
  • str_squish：删除字符串中多于1个的空格。非常有用的函数！
  • str_dup: 复制字符串
  • str_sub: 字符串切片
  • str_sub<- 字符串切片，并赋值，同str_sub

字符串计算函数

  • str_count: 字符串计数
  • str_length(): 字符串长度，同nchar()
  • str_sort: 字符串值排序
  • str_order: 字符串索引排序，规则同str_sort

字符串匹配函数

  • str_view()/str_view_all() 查看string是否匹配pattern，如果匹配，就高亮显示
  • str_split: 字符串分割
  • str_split_fixed: 字符串分割，同str_split
  • str_subset: 返回匹配的字符串
  • word: 从文本中提取单词
  • str_detect()/str_view(): 检查匹配字符串的字符
  • str_match: 从字符串中提取匹配组。
  • str_match_all: 从字符串中提取匹配组，同str_match
  • chartr(old, new, string): 从 old 到 new 的一一对应的替换，作用在 string 上
  • str_replace: 字符串替换
  • str_replace_all: 字符串替换，同str_replace
  • str_replace_na: 把NA替换为字符串”NA”
  • str_remove：删除匹配的字符串
  • str_remove_all：删除所有匹配的字符
  • str_locate: 找到匹配的字符串的位置。
  • str_locate_all: 找到匹配的字符串的位置,同str_locate
  • str_extract: 从字符串中提取匹配字符
  • str_extract_all: 从字符串中提取匹配字符，同str_extract

字符串格式化

  • base::sprintf()，详见上一节
  • str_glue()：参数里面的{}占位符，同javascript的${}
  • str_wrap: 控制长字符串输出排版
  • str_conv: 字符编码转换
  • str_to_upper()/toupper(): 字符串转成大写
  • str_to_lower()/tolower(): 字符串转成小写,规则同str_to_upper
  • str_to_title(): 字符串转成首字母大写,规则同str_to_upper
  • str_to_sentence(): 只有一句的首字母大写

参数控制函数，仅用于构造功能的参数，不能独立使用。

  • boundary: 定义使用边界
  • coll: 定义字符串标准排序规则。
  • fixed: 定义用于匹配的字符，包括正则表达式中的转义符
  • regex: 定义正则表达式

stringr::

stringr cheatsheet.pdf

str_length() 字符串长度

同 base::nchar()

使用 RStudio，那么通用前缀 str_ 会特别有用，因为输入 str_ 后会触发自动完成功能，你可以看到所有的字符串函数：

str_length(c("a", "R for data science"))
#> [1]  1 18
str_length(c("a", "R for data science")) %>% sum()
#> [1] 19

str_c()字符串组合

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

合并若干个字符串或字符向量的对应元素，默认无间隔符

# 向量化操作，自动循环短向量
str_c("prefix-", c("a", "b", "c"), "-suffix")
#> [1] "prefix-a-suffix" "prefix-b-suffix" "prefix-c-suffix"
# 合并一个字符向量的各元素为一个长字符串，使用参数collapse，将向量“塌缩”为一个字符串
str_c(c("x", "y", "z"), collapse = "+")
#> [1] "x+y+z"

str_replace_na(string, replacement = "NA")，默认将 na 转化为字符串”NA”

x <- c("abc", NA)
str_c("|-", x, "-|")
#> [1] "|-abc-|" NA
str_c("|-", str_replace_na(x), "-|")
#> [1] "|-abc-|" "|-NA-|"

str_trim() 去掉字符串首尾的空格和制表符(\t)

str_trim(string, side = c(“both”, “left”, “right”))

side: 过滤方式，both两边都过滤，left左边过滤，right右边过滤

str_pad() 补充字符串的长度

str_pad(string, width, side = c(“left”, “right”, “both”), pad = ” “)

width: 字符串填充后的长度
side: 填充方向，both两边都填充，left左边填充，right右边填充
pad: 用于填充的字符

str_dup() 复制字符串

str_dup(string, times)

times: 复制次数

val <- c("abca4", 123, "cba2")

# 复制2次
str_dup(val, 2)
#> [1] "abca4abca4" "123123"     "cba2cba2"
# 按位置复制
str_dup(val, 1:3)
#> [1] "abca4"        "123123"       "cba2cba2cba2"

str_wrap() 控制长字符串输出排版

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

width: 设置一行所占的宽度。
indent: 段落首行的缩进值
exdent: 段落非首行的缩进值

# 这段代码可以在 console 中运行，但不能在 Rmarkdown 中直接运行
str <- "R语言作为统计学一门语言，一直在小众领域闪耀着光芒。直到大数据的爆发，R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入，R语言的社区在迅速扩大成长。现在已不仅仅是统计领域，教育，银行，电商，互联网….都在使用R语言。"


# 设置宽度为40个字符
# cat(str_wrap(str, width = 40), "\n")

# 设置宽度为60字符，首行缩进4字符
# cat(str_wrap(txt, width = 60, indent = 4), "\n")

# 设置宽度为10字符，非首行缩进4字符
# cat(str_wrap(txt, width = 10, exdent = 4), "\n")

str_split() 拆分字符串

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

pattern: 匹配的字符。
n: 分割个数

val <- "abc,123,234,iuuu"

# 以,进行分割
s1 <- str_split(val, ",")
s1
#> [[1]]
#> [1] "abc"  "123"  "234"  "iuuu"
# 以,进行分割，且只保留2块
s2 <- str_split(val, ",", 2)
s2
#> [[1]]
#> [1] "abc"          "123,234,iuuu"
# 查看str_split()函数操作的结果类型list
class(s1)
#> [1] "list"
# 用str_split_fixed()函数分割，结果类型是matrix
s3 <- str_split_fixed(val, ",", 2)
s3
#>      [,1]  [,2]          
#> [1,] "abc" "123,234,iuuu"
class(s3)
#> [1] "matrix" "array"
fruits <- c(
  "apples and oranges and pears and bananas",
  "pineapples and mangos and guavas"
)
str_split(fruits, " and ")
#> [[1]]
#> [1] "apples"  "oranges" "pears"   "bananas"
#> 
#> [[2]]
#> [1] "pineapples" "mangos"     "guavas"
gpl <- readLines(file.path(R.home(), "COPYING"))
words <- unlist(strsplit(gpl, "\\W")) # \\W 意为非单词字符
words <- words[words != ""] # 去掉空字符
tail(sort(table(tolower(words))), 10) # 频数最大的10个单词
#> 
#>    this      is       a program     and     you      or      of      to     the 
#>      49      53      57      71      72      76      77     104     108     194

str_sub() 字符串取子集

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

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

两个参数分别为始末位置，符号代表从后往前数第多少个字符

txt <- "I am Conan."

# 分2段截取字符串
str_sub(txt, c(1, 4), c(6, 8))
#> [1] "I am C" "m Con"
# 通过负坐标截取字符串
str_sub(txt, -3)
#> [1] "an."
str_sub(txt, end = -3)
#> [1] "I am Cona"
# 赋值
x <- c("Apple", "Banana", "Pear")
# str_sub()对x向量化操作；str_to_lower全部转换为小写字母
str_sub(x, 1, 1) <- str_to_lower(str_sub(x, 1, 1))
x
#> [1] "apple"  "banana" "pear"

str_to_*() 大小写函数族

str_to_upper(string, locale = "") 转换为全大写字母

str_to_lower(string, locale = "") 转换为全小写字母

str_to_title(string, locale = "") 单词首字母大写

str_to_sentence() 全句首字母大写

locale:按哪种语言习惯排序

dog <- "Look the quick brown dog!"
str_to_upper(dog)
#> [1] "LOOK THE QUICK BROWN DOG!"
str_to_lower(dog)
#> [1] "look the quick brown dog!"
str_to_title(dog)
#> [1] "Look The Quick Brown Dog!"
str_to_sentence("look the quick brown dog!")
#> [1] "Look the quick brown dog!"

str_count() 字符串计数

str_count(string, pattern = ““)

# 注意正则表达式的特殊字符
str_count(c("a.", ".", ".a.", NA), ".")
#> [1]  2  1  3 NA
# 用fixed匹配字符
str_count(c("a.", ".", ".a.", NA), fixed("."))
#> [1]  1  1  2 NA
# 用\\匹配字符
str_count(c("a.", ".", ".a.", NA), "\\.")
#> [1]  1  1  2 NA

str_sort() 字符串排序

str_sort(x, decreasing = FALSE, na_last = TRUE, locale = ““, …) str_order(x, decreasing = FALSE, na_last = TRUE, locale =”“, …)

x: 字符串，字符串向量。 decreasing: 排序方向。 na_last: NA值的存放位置，一共3个值，TRUE放到最后，FALSE放到最前，NA过滤处理 locale: 按哪种语言习惯排序

# 按ASCII字母排序
str_sort(c("a", 1, 2, "11"), locale = "en")
#> [1] "1"  "11" "2"  "a"
# 倒序排序
str_sort(letters, decreasing = TRUE)
#>  [1] "z" "y" "x" "w" "v" "u" "t" "s" "r" "q" "p" "o" "n" "m" "l" "k" "j" "i" "h"
#> [20] "g" "f" "e" "d" "c" "b" "a"
# 按拼音排序
str_sort(c("你", "好", "粉", "丝", "日", "志"), locale = "zh")
#> [1] "粉" "好" "你" "日" "丝" "志"

对NA的排序处理：

# 把NA放最后面
str_sort(c(NA, "1", NA), na_last = TRUE)
#> [1] "1" NA  NA
# 把NA放最前面
str_sort(c(NA, "1", NA), na_last = FALSE)
#> [1] NA  NA  "1"
# 去掉NA值
str_sort(c(NA, "1", NA), na_last = NA)
#> [1] "1"

str_detect() 检测是否匹配，返回T/F

val <- c("abca4", 123, "cba2")

# 检查字符串向量，是否包括a
str_detect(val, "a")
#> [1]  TRUE FALSE  TRUE
# 检查字符串向量，是否以a为开头
str_detect(val, "^a")
#> [1]  TRUE FALSE FALSE
# 检查字符串向量，是否以a为结尾
str_detect(val, "a$")
#> [1] FALSE FALSE FALSE

str_subset() 返回成功匹配的字符串

val <- c("abc", 123, "cba")

# 全文匹配
str_subset(val, "a")
#> [1] "abc" "cba"
# 开头匹配
str_subset(val, "^a")
#> [1] "abc"
# 结尾匹配
str_subset(val, "a$")
#> [1] "cba"

str_match()/str_extract() 从字符串中提取匹配模式

主要与正则表达式配合使用

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

以字符串matrix格式返回

val <- c("abc", 123, "cba")

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

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

simplify: TRUE返回matrix，FALSE返回列表

val <- c("abca4", 123, "cba2")

# 返回匹配的数字
str_extract(val, "\\d")
#> [1] "4" "1" "2"
# 返回匹配的字符
str_extract(val, "[a-z]+")
#> [1] "abca" NA     "cba"
val <- c("abca4", 123, "cba2")
str_extract_all(val, "\\d")
#> [[1]]
#> [1] "4"
#> 
#> [[2]]
#> [1] "1" "2" "3"
#> 
#> [[3]]
#> [1] "2"
str_extract_all(val, "[a-z]+")
#> [[1]]
#> [1] "abca"
#> 
#> [[2]]
#> character(0)
#> 
#> [[3]]
#> [1] "cba"

word() 从文本中提取单词（以单词为单位看待字符串）

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

start: 从第几个词开始。 end: 到第几个词结束。 sep: 分词间隔字符，默认为空格。

val <- c("I am Conan.", "http://fens.me, ok")

# 默认以空格分割，取第一个位置的字符串
word(val, 1)
#> [1] "I"               "http://fens.me,"
word(val, -1)
#> [1] "Conan." "ok"
word(val, 2, -1)
#> [1] "am Conan." "ok"
# 以,分割，取第一个位置的字符串
val <- "111,222,333,444"
word(val, 1, sep = fixed(","))
#> [1] "111"
word(val, 3, sep = fixed(","))
#> [1] "333"

str_replace() 字符串替换

str_replace(string, pattern, replacement)
str_replace_all(string, pattern, replacement)
str_replace_na(string, replacement = “NA”), 将NA（默认）替换为’NA’

参数 replacement 可以是一个函数，使替换的规则更加复杂

val <- c("abc", 123, "cba")

# 把目标字符串第一个出现的a或b，替换为-
str_replace(val, "[ab]", "-")
#> [1] "-bc" "123" "c-a"
# 把目标字符串所有出现的a或b，替换为-
str_replace_all(val, "[ab]", "-")
#> [1] "--c" "123" "c--"
# 把目标字符串所有出现的a，替换为被转义的字符
str_replace_all(val, "[a]", "\\")
#> [1] "bc"  "123" "cb"
pigIt <- function(string) {
  str_replace_all(string, "\\w+", function(word) {
    str_c(str_sub(word, 2), str_sub(word, 1, 1), "ay")
  })
}

library(testthat)
#> 
#> Attaching package: 'testthat'
#> The following objects are masked from 'package:magrittr':
#> 
#>     equals, is_less_than, not
#> The following object is masked from 'package:dplyr':
#> 
#>     matches
#> The following object is masked from 'package:purrr':
#> 
#>     is_null
#> The following objects are masked from 'package:readr':
#> 
#>     edition_get, local_edition
#> The following object is masked from 'package:tidyr':
#> 
#>     matches
test_that("Sample Tests", {
  expect_equal(pigIt("Pig latin is cool"), "igPay atinlay siay oolcay")
  expect_equal(pigIt("Hello world !"), "elloHay orldway !")
})
#> Test passed 😀

str_locate() 找到模式在字符串中的始末位置

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

val <- c("abca", 123, "cba")

# 匹配a在字符串中的位置
str_locate(val, "a")
#>      start end
#> [1,]     1   1
#> [2,]    NA  NA
#> [3,]     3   3
# 用向量匹配
str_locate(val, c("a", 12, "b"))
#>      start end
#> [1,]     1   1
#> [2,]     1   2
#> [3,]     2   2
# 以字符串matrix格式返回
str_locate_all(val, "a")
#> [[1]]
#>      start end
#> [1,]     1   1
#> [2,]     4   4
#> 
#> [[2]]
#>      start end
#> 
#> [[3]]
#>      start end
#> [1,]     3   3
# 匹配a或b字符，以字符串matrix格式返回
str_locate_all(val, "[ab]")
#> [[1]]
#>      start end
#> [1,]     1   1
#> [2,]     2   2
#> [3,]     4   4
#> 
#> [[2]]
#>      start end
#> 
#> [[3]]
#>      start end
#> [1,]     2   2
#> [2,]     3   3

str_conv 字符编码转换

str_conv(string, encoding)

# 把中文字符字节化
x <- charToRaw("你好")
x
#> [1] e4 bd a0 e5 a5 bd
# 默认win系统字符集为GBK，GB2312为GBK字集，转码正常
str_conv(x, "GBK")
#> [1] "浣犲ソ"
str_conv(x, "GB2312")
#> Warning in stri_conv(string, encoding, "UTF-8"): input data \xffffffa0 in the
#> current source encoding could not be converted to Unicode
#> Warning in stri_conv(string, encoding, "UTF-8"): input data \xffffffbd in the
#> current source encoding could not be converted to Unicode
#> [1] "浣\032濂\032"
# 转UTF-8失败
str_conv(x, "UTF-8")
#> [1] "你好"
# 把unicode转UTF-8
str_conv("\u5317\u4eac", "UTF-8")
#> [1] "北京"

str_glue() 模板字符串

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, %Y')}."
)
#> 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}.

base::

chartr() 字符替换

chartr(old, new, x)，非常好用的函数，相当于按一个哈希表进行字符转换

chartr(old = "a", new = "c", x = "a123")
#> [1] "c123"
# 注意，old和new参数可以都是字符串，index 对应的字符进行任意次数的替换
chartr("Tt", "Uu", "AtGCtttACC")
#> [1] "AuGCuuuACC"

字符串分割

strsplit(x, split, fixed = FALSE)

# fixed=F, 第2个参数为正则表达式。'.'可匹配除“\n”和"\r"之外的任何单个字符。
splited <- unlist(strsplit("a.b.c", "."))
splited
#> [1] "" "" "" "" ""
# fixed=T，第2个参数为文本字符串
splited <- unlist(strsplit("a.b.c", ".", fixed = T))
splited
#> [1] "a" "b" "c"

字符串匹配

字符串匹配函数 grep(pattern, x, fixed=FALSE)和grepl()

cstr <- c("b", "A", "c", "a.a")
# fixed=T，第1个参数为文本字符串
grep(".", cstr, fixed = TRUE)
#> [1] 4
# fixed=F，第1个参数为正则表达式
grep(".", cstr, fixed = F)
#> [1] 1 2 3 4
# grep仅返回匹配项的下标；而grepl返回逻辑向量表示有没有找到匹配
grepl(".", cstr, fixed = TRUE)
#> [1] FALSE FALSE FALSE  TRUE
# 用于提取子集是一样的
cstr[grep(".", cstr, fixed = TRUE)]
#> [1] "a.a"
cstr[grepl(".", cstr, fixed = TRUE)]
#> [1] "a.a"

字符串替换

字符串替换函数 sub(pattern, replacement, x, fixed=FALSE)

# fixed=F, 第1个参数为正则表达式，'\\s'表示空白
sub("\\s", ".", "Hello There")
#> [1] "Hello.There"
# fixed=T, 第1个参数为文本字符串，在'Hello There'中找不到'\\s'
sub("\\s", ".", "Hello There", fixed = T)
#> [1] "Hello There"
# sub()与gsub()的区别，替换一次和替换任意次（只要匹配成功）
sub("e", "E", "Hello There", fixed = T)
#> [1] "HEllo There"
gsub("e", "E", "Hello There", fixed = T)
#> [1] "HEllo ThErE"
---
title: "String"
subtitle: ''
author: "Humoon"
date: "`r Sys.Date()`"
output:
  html_document: 
    code_download: true
    css: ["../css/style.css"]
    fig_caption: yes
    theme: united
    highlight: haddock
    number_sections: no
    toc: yes
    toc_depth: 4
    toc_float:
      collapsed: yes
      smooth_scroll: yes
documentclass: ctexart
classoption: hyperref,
---

```{r setup, include = FALSE}
source("../Rmarkdown-template/Rmarkdown_config.R")

## global options ===================================
knitr::opts_chunk$set(
  width = config$width,
  fig.width = config$fig.width,
  fig.asp = config$fig.asp,
  out.width = config$out.width,
  fig.align = config$fig.align,
  fig.path = config$fig.path,
  fig.show = config$fig.show,
  warn = config$warn,
  warning = config$warning,
  message = config$message,
  echo = config$echo, 
  eval = config$eval, 
  tidy = config$tidy, 
  comment = config$comment, 
  collapse = config$collapse, 
  cache = config$cache,
  cache.comments = config$cache.comments,
  autodep = config$autodep
)

## use necessary packages ==============================
library(tidyverse)
library(data.table)
library(magrittr)
library(plotly)
library(htmlwidgets)
```

**字符串函数一般都是向量化的，对输入的字符串向量的每个元素进行操作**。

## 字符串基础

### readLines()

1.  在R中读入一个文本文件可以用`readLines()`函数，它返回一个字符型向量，文件中每一行都是向量中对应的一个元素。这个文件可以是本地文件，也可以是一个网址。

```{r}
index <- readLines("https://www.baidu.com") # 我的主页
head(index) # HTML代码
```

2.  `readline()`支持从键盘直接输入一行文本，显然，R必须在交互式模式下运行，否则人没法输入任何东西。它有一个常用的地方，就是在代码运行过程中要求用户输入一些回答，例如：

```{r, eval=FALSE}
x <- readline("Answer yes or no: ")
```

当R运行到这一行时会停下来等待用户输入（回车表示输入结束），然后根据输入的结果，代码可以接着执行。

3.  在Windows系统中，`readLines()`读utf-8编码的txt文件会导致乱码，只能顺利读取ANSI编码的txt文件。

### writeLines()

1.  注意，字符串的打印形式与其本身的内容不是相同的，因为打印形式中会显示出转义字符。**如果想要查看字符串的真正内容，可以使用`writeLines()`**

> writeLines(text, con = stdout(), sep = "\n", useBytes = FALSE)

2.  Windows系统中`writeLines()`写入txt文件会导致乱码，替代方案是用`writeBin(charToRaw(string), file)`写入文件

### 字符串包含引文时引号的使用

若一个字符串包含引文，为了符合行文习惯(双引号)，并使代码引号有层次的区别，外层应用单引号。

```{r quote, results='hold'}
# string1 <- 'When putting a 'quote' inside a string, use single quotation marks.'
# string1 <- "When putting a "quote" inside a string, use double quotation marks."
string3 <- "When putting a 'quote' inside a string, use single quotation marks inside and double quotation marks outside."
string4 <- 'When putting a "quote" inside a string, use double quotation marks inside and single quotation marks outside.'

# 字符串的打印形式
string3
string4
```

```{r, results='hold'}
# 字符串编译后导出的形式
writeLines(string3)
writeLines(string4)
```

string1和string2有语法错误，前后两个字符串中间夹了一个编译器不认识的quote。

string3和string4在语法上没问题，但编译时效果不同。string4才是我们想要的。

### 转义符号"\\"

反斜杠"\\"可以将R语言及R Markdown的语法部件转义为字符。\
如果想要在字符串中包含一个单引号或双引号，可以使用"\\'"和"\\""对其进行转义。

```{r, results='hold'}
string5 <- 'I don\'t know why they called us "Chinese".'
string6 <- "When putting a \"quote\" inside a string, you can use backslash as well."
writeLines(string5)
writeLines(string6)
```

如果想要在字符串中包含一个反斜杠，就需要使用两个反斜杠："\\\\"

```{r, results='hold'}
string7 <- "I think the backslash \"\\\" is amazing!"
print(string7) # 或 string7
writeLines(string7)
```

### 特殊字符

其他几种特殊字符。最常用的是换行符"\\n"、制表符"\\t"和退格"\\b"，你可以使用 ?'"' 或 ?"'" 调出帮助文件来查看完整的特殊字符列表。

```{r, results='hold'}
string8 <- 'The special characters "\n", "\t" and "\b" are very interesing.'
string9 <- "The special characters \"\\n\", \"\\t\" and \"\\b\" are very interesing."
writeLines(string8)
writeLines(string9)
```

生成的html文件中"\\b"变成了一个奇怪的方框，控制台显示的则是正确的。可能R Markdown与R语言中"\\b"的含义不同。

## 字符串格式化

### base::sprintf()

`sprintf(包含占位符的字符串，欲填充的字符串)`

| **占位符**      |                                                                                                  |
|-----------------|--------------------------------------------------------------------------------------------------|
| \%              | 如果要在占位符内部使用%，需要写成%%                                                              |
| **转换符**      | **类型**                                                                                         |
| d               | 十进制整数                                                                                       |
| o               | 八进制整数                                                                                       |
| x, X            | 小/大写十六进制整数                                                                              |
| f               | 十进制浮点数                                                                                     |
| e, E            | 科学计数法表示的数，e小写或大写                                                                  |
| g, G            | 智能选择使用浮点数还是科学计数法（g对应e，G对应E），默认显示6位有效数字                          |
| s               | 字符串                                                                                           |
| **浮点数格式**  |                                                                                                  |
| width.precision | 输出的最小宽度（不足以空格补齐）.输出精度（对f和e/E意味着小数点后几位，对g/G意味着有效数字位数） |
| \-              | 指定左对齐（默认右对齐），即宽度不足时从右边补充空格                                             |
| \+              | 永远带符号（默认只有负数带一个负号，正数不带符号）                                               |
| 空格            | 首字符并非负号时，空一格                                                                         |
| 0               | 宽度不足时补0，而非默认的空格                                                                    |

```{r}
sprintf("The ratio is %d%%", 10)


sprintf("%f", pi) # 浮点数
sprintf("%.3f", pi) # 保留小数点后3位
sprintf("%.0f", pi) # 保留小数点后0位
sprintf("%5.1f", pi) # 最小宽度为5，保留小数点后1位，不足补空格
sprintf("%05.1f", pi) # 用0补齐
sprintf("%+f", pi) # 永远带符号
sprintf("% f", pi)
sprintf("%-10f", pi) # 左对齐，宽度为10
sprintf("%e", pi)
sprintf("%E", pi)
sprintf("%g", pi)
sprintf("%g", 1e6 * pi)
sprintf("%.9g", 1e6 * pi)
sprintf("%.2g", 23.75)

sprintf(
  "min 10-char string '%10s'",
  c("a", "ABC", "and an even longer one")
)
```

### 借助 python

加入 python 代码块，使用 python 中的字符串格式化方法 .format()

`模板字符串.format(以逗号分隔的填充参数序列)`

其中，`{}`为模板中的槽，槽内部定义每个槽的格式化样式，形如：

`id:[fill][align][sign][width][,][.precision][type]`

+------------+-----------------------------------------------------------------------------------------------+
| 类别       | 含义                                                                                          |
+============+===============================================================================================+
| fill       | 宽度不足时填充的字符                                                                          |
+------------+-----------------------------------------------------------------------------------------------+
| align      | 对齐方式. `<` 左对齐；`>` 右对齐；`=` 内容右对齐，符号放置在填充字符（如"0"）的左侧；`^` 居中 |
+------------+-----------------------------------------------------------------------------------------------+
| sign       | `+` 正数加`+`，负数加`-`                                                                      |
|            |                                                                                               |
|            | 空格，正数加空格，负数加`-`                                                                   |
+------------+-----------------------------------------------------------------------------------------------+
| ,          | 为数字添加千位分隔符                                                                          |
+------------+-----------------------------------------------------------------------------------------------+
| width      | 输出的最小宽度（不足以 fill 补齐）                                                            |
+------------+-----------------------------------------------------------------------------------------------+
| .precision | 小数点后保留精度                                                                              |
+------------+-----------------------------------------------------------------------------------------------+
| type       | 格式化类型                                                                                    |
+------------+-----------------------------------------------------------------------------------------------+
|            | s 字符串（不指定type时默认）                                                                  |
+------------+-----------------------------------------------------------------------------------------------+
|            | d 十进制整数                                                                                  |
+------------+-----------------------------------------------------------------------------------------------+
|            | o 八进制整数                                                                                  |
+------------+-----------------------------------------------------------------------------------------------+
|            | x, X 小/大写十六进制整数                                                                      |
+------------+-----------------------------------------------------------------------------------------------+
|            | f 十进制浮点数                                                                                |
+------------+-----------------------------------------------------------------------------------------------+
|            | e, E 科学计数法表示的数，e小写或大写                                                          |
+------------+-----------------------------------------------------------------------------------------------+
|            | g, G 智能选择使用浮点数还是科学计数法（g对应e，G对应E），默认显示6位有效数字                  |
+------------+-----------------------------------------------------------------------------------------------+
|            | \% 百分比，默认显示小数点后6位                                                                |
+------------+-----------------------------------------------------------------------------------------------+
|            | b 二进制整数                                                                                  |
+------------+-----------------------------------------------------------------------------------------------+
|            | c 10进制整数转换为 Unicode 字符                                                               |
+------------+-----------------------------------------------------------------------------------------------+

这种方法的缺点在于，输出宽度、精度等参数必须是确定的常数，而不能是变量。因此当这些数值必须取变量时，仍要使用`.rjust()`、`.ljust()`和`.center()`方法。

示例：

```{python}
str1 = "{0:=^20}".format("Python") 
str1 # 用 '=' 填充，居中对齐，槽宽度为20

str2 = "{:=^20}".format("Python") 
str2 # 参数索引0可以省略

str3 = "{:*>20}".format("BIT") 
str3 # 用 '*' 填充，右对齐，槽宽度为20

str4 = "{:10}".format("BIT")
str4 # 默认左对齐，空格填充

str5 = "{:,.2f}".format(12345.6789)
str5 # 使用千位分隔符，保留两位小数的浮点型

str6 = "{0:b}, {0:c}, {0:d}, {0:o}, {0:x}, {0:X}".format(426)
str6 # 一个参数填到所有槽中，分别转换为：二进制，Unicode 编码，十进制，八进制，十六进制，大写的十六进制

str7 = "{0:.2e}, {0:.2E}, {0:.2f}, {0:.2%}".format(3.14)
str7 # 分别转换为：科学记数法，大写科学记数法，浮点数，百分数

str8  = "I am {:s}, age {:d}, money {:.2f}".format("seven", 18, 88888.1)
str8 # 槽与填充参数的顺序恰好对应时，也可以省略参数索引
```

### formattable 包

- percent()
- comma()
- currency()
- accounting()，会计格式，如负数用括号表示
- scientific()


```{r}
library(formattable)

df <-
  data.frame(
    id = 1:10,
    name = c(
      "Bob",
      "Ashley",
      "James",
      "David",
      "Jenny",
      "Hans",
      "Leo",
      "John",
      "Emily",
      "Lee"
    ),
    age = c(28, 27, 30, 28, 29, 29, 27, 27, 31, 30),
    grade = c("C", "A", "A", "C", "B", "B", "B", "A", "C", "C"),
    test1_score = c(8.9, 9.5, 9.6, 8.9, 9.1, 9.3, 9.3, 9.9, 8.5, 8.6),
    test2_score = c(9.1, 9.1, 9.2, 9.1, 8.9, 8.5, 9.2, 9.3, 9.1, 8.8),
    final_score = c(9, 9.3, 9.4, 9, 9, 8.9, 9.25, 9.6, 8.8, 8.7),
    registered = c(TRUE, FALSE, TRUE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE),
    stringsAsFactors = FALSE
  )
df

formattable(
  df,
  list(
    age = color_tile("white", "orange"),
    grade = formatter("span", style = x ~ ifelse(
      x == "A", style(color = "green", font.weight = "bold"), NA
    )),
    area(col = c(test1_score, test2_score)) ~ normalize_bar("pink", 0.2),
    final_score = formatter(
      "span",
      style = x ~ style(color = ifelse(rank(-x) <= 3, "green", "gray")),
      x ~ sprintf("%.2f (rank: %02d)", x, rank(-x))
    ),
    registered = formatter(
      "span",
      style = x ~ style(color = ifelse(x, "green", "red")),
      x ~ icontext(ifelse(x, "ok", "remove"), ifelse(x, "Yes", "No"))
    )
  )
)
```
`文字格式自定义`、`文字背景自定义`、`文本自定义`三种自定义可视化类型：

- color_tile函数用于输出按照数值量级进行颜色背景填充的列。
- formatter函数提供字体显示格式的自定义，grade列自定义了值为A的记录显示绿色，并将字体加粗，否则忽略。
- test1_score, test2_score两列通过area函数在对应字体背景位置使用条形图来代表指标量级大小，颜色填充粉色。
- final_score列对指标按照top3显示绿色，其余显示灰色，同时将内容显示格式自定义为浮点型+(rank:名次)进行显示。
- registered列则在对填充颜色按照对应布尔值进行显示（TRUE显示绿色、FALSE显示红色）之外，在左侧添加了对用的icon文本（TRUE显示绿色对号，FALSE显示红色叉号）。


## 函数分类

**字符串拼接函数**

-   str_c: 字符串拼接。
-   str_trim: 去掉字符串的白空格
-   str_pad: 补充字符串的长度
-   `str_squish`：删除字符串中多于1个的空格。非常有用的函数！
-   str_dup: 复制字符串
-   str_sub: 字符串切片
-   str_sub\<- 字符串切片，并赋值，同str_sub

**字符串计算函数**

-   str_count: 字符串计数
-   `str_length()`: 字符串长度，同`nchar()`
-   str_sort: 字符串值排序
-   str_order: 字符串索引排序，规则同str_sort

**字符串匹配函数**

-   `str_view()/str_view_all()` 查看string是否匹配pattern，如果匹配，就高亮显示
-   str_split: 字符串分割
-   str_split_fixed: 字符串分割，同str_split
-   str_subset: 返回匹配的字符串
-   word: 从文本中提取单词
-   `str_detect()`/`str_view()`: 检查匹配字符串的字符
-   str_match: 从字符串中提取匹配组。
-   str_match_all: 从字符串中提取匹配组，同str_match
-   `chartr(old, new, string)`: 从 old 到 new 的一一对应的替换，作用在 string 上
-   str_replace: 字符串替换
-   str_replace_all: 字符串替换，同str_replace
-   str_replace_na: 把NA替换为字符串"NA"
-   str_remove：删除匹配的字符串
-   str_remove_all：删除所有匹配的字符
-   str_locate: 找到匹配的字符串的位置。
-   str_locate_all: 找到匹配的字符串的位置,同str_locate
-   str_extract: 从字符串中提取匹配字符
-   str_extract_all: 从字符串中提取匹配字符，同str_extract

**字符串格式化**

- `base::sprintf()`，详见上一节
-   `str_glue()`：参数里面的`{}`占位符，同javascript的`${}`
-   str_wrap: 控制长字符串输出排版
-   str_conv: 字符编码转换
-   `str_to_upper()`/`toupper()`: 字符串转成大写
-   `str_to_lower()`/`tolower()`: 字符串转成小写,规则同str_to_upper
-   str_to_title(): 字符串转成首字母大写,规则同str_to_upper
-   str_to_sentence(): 只有一句的首字母大写

**参数控制函数，仅用于构造功能的参数，不能独立使用。**

-   boundary: 定义使用边界
-   coll: 定义字符串标准排序规则。
-   fixed: 定义用于匹配的字符，包括正则表达式中的转义符
-   regex: 定义正则表达式


## stringr::

<a href="../pdf/cheatsheet-strings.pdf"><strong>stringr cheatsheet.pdf</strong></a>

<object data="../pdf/cheatsheet-strings.pdf" type="application/pdf" width="100%" height="100%"></object>


### `str_length()` 字符串长度

同 `base::nchar()`

使用 RStudio，那么通用前缀 str\_ 会特别有用，因为输入 str\_ 后会触发自动完成功能，你可以看到所有的字符串函数：

```{r}
str_length(c("a", "R for data science"))
str_length(c("a", "R for data science")) %>% sum()
```

### `str_c()`字符串组合

`str_c(..., sep = "", collapse = NULL)`

合并若干个字符串或字符向量的对应元素，默认无间隔符

```{r}
# 向量化操作，自动循环短向量
str_c("prefix-", c("a", "b", "c"), "-suffix")
```

```{r}
# 合并一个字符向量的各元素为一个长字符串，使用参数collapse，将向量“塌缩”为一个字符串
str_c(c("x", "y", "z"), collapse = "+")
```


`str_replace_na(string, replacement = "NA")`，默认将 na 转化为字符串"NA"

```{r}
x <- c("abc", NA)
str_c("|-", x, "-|")

str_c("|-", str_replace_na(x), "-|")
```

### `str_trim()` 去掉字符串首尾的空格和制表符(\\t)

> str_trim(string, side = c("both", "left", "right"))

side: 过滤方式，both两边都过滤，left左边过滤，right右边过滤

### `str_pad()` 补充字符串的长度

> str_pad(string, width, side = c("left", "right", "both"), pad = " ")

width: 字符串填充后的长度\
side: 填充方向，both两边都填充，left左边填充，right右边填充\
pad: 用于填充的字符

### `str_dup()` 复制字符串

> str_dup(string, times)

times: 复制次数

```{r}
val <- c("abca4", 123, "cba2")

# 复制2次
str_dup(val, 2)

# 按位置复制
str_dup(val, 1:3)
```

### `str_wrap()` 控制长字符串输出排版

> str_wrap(string, width = 80, indent = 0, exdent = 0)

width: 设置一行所占的宽度。\
indent: 段落首行的缩进值\
exdent: 段落非首行的缩进值


```{r}
# 这段代码可以在 console 中运行，但不能在 Rmarkdown 中直接运行
str <- "R语言作为统计学一门语言，一直在小众领域闪耀着光芒。直到大数据的爆发，R语言变成了一门炙手可热的数据分析的利器。随着越来越多的工程背景的人的加入，R语言的社区在迅速扩大成长。现在已不仅仅是统计领域，教育，银行，电商，互联网….都在使用R语言。"


# 设置宽度为40个字符
# cat(str_wrap(str, width = 40), "\n")

# 设置宽度为60字符，首行缩进4字符
# cat(str_wrap(txt, width = 60, indent = 4), "\n")

# 设置宽度为10字符，非首行缩进4字符
# cat(str_wrap(txt, width = 10, exdent = 4), "\n")
```

### `str_split()` 拆分字符串

> str_split(string, pattern, n = Inf) str_split_fixed(string, pattern, n)

pattern: 匹配的字符。\
n: 分割个数

```{r}
val <- "abc,123,234,iuuu"

# 以,进行分割
s1 <- str_split(val, ",")
s1

# 以,进行分割，且只保留2块
s2 <- str_split(val, ",", 2)
s2

# 查看str_split()函数操作的结果类型list
class(s1)

# 用str_split_fixed()函数分割，结果类型是matrix
s3 <- str_split_fixed(val, ",", 2)
s3
class(s3)


fruits <- c(
  "apples and oranges and pears and bananas",
  "pineapples and mangos and guavas"
)
str_split(fruits, " and ")


gpl <- readLines(file.path(R.home(), "COPYING"))
words <- unlist(strsplit(gpl, "\\W")) # \\W 意为非单词字符
words <- words[words != ""] # 去掉空字符
tail(sort(table(tolower(words))), 10) # 频数最大的10个单词
```

### `str_sub()` 字符串取子集

> str_sub(string, start = 1L, end = -1L)

> str_sub(string, start = 1L, end = -1L) \<- value

两个参数分别为始末位置，符号代表从后往前数第多少个字符

```{r}
txt <- "I am Conan."

# 分2段截取字符串
str_sub(txt, c(1, 4), c(6, 8))

# 通过负坐标截取字符串
str_sub(txt, -3)
str_sub(txt, end = -3)

# 赋值
x <- c("Apple", "Banana", "Pear")
# str_sub()对x向量化操作；str_to_lower全部转换为小写字母
str_sub(x, 1, 1) <- str_to_lower(str_sub(x, 1, 1))
x
```

### `str_to_*()` 大小写函数族

`str_to_upper(string, locale = "")` 转换为全大写字母

`str_to_lower(string, locale = "")` 转换为全小写字母

`str_to_title(string, locale = "")` 单词首字母大写

`str_to_sentence()` 全句首字母大写

locale:按哪种语言习惯排序

```{r}
dog <- "Look the quick brown dog!"
str_to_upper(dog)
str_to_lower(dog)
str_to_title(dog)
str_to_sentence("look the quick brown dog!")
```

### `str_count()` 字符串计数

> str_count(string, pattern = "")

```{r}
# 注意正则表达式的特殊字符
str_count(c("a.", ".", ".a.", NA), ".")

# 用fixed匹配字符
str_count(c("a.", ".", ".a.", NA), fixed("."))

# 用\\匹配字符
str_count(c("a.", ".", ".a.", NA), "\\.")
```

### `str_sort()` 字符串排序

> str_sort(x, decreasing = FALSE, na_last = TRUE, locale = "", ...) str_order(x, decreasing = FALSE, na_last = TRUE, locale = "", ...)

x: 字符串，字符串向量。 decreasing: 排序方向。 na_last: NA值的存放位置，一共3个值，TRUE放到最后，FALSE放到最前，NA过滤处理 locale: 按哪种语言习惯排序

```{r}
# 按ASCII字母排序
str_sort(c("a", 1, 2, "11"), locale = "en")

# 倒序排序
str_sort(letters, decreasing = TRUE)

# 按拼音排序
str_sort(c("你", "好", "粉", "丝", "日", "志"), locale = "zh")
```

对NA的排序处理：

```{r}
# 把NA放最后面
str_sort(c(NA, "1", NA), na_last = TRUE)

# 把NA放最前面
str_sort(c(NA, "1", NA), na_last = FALSE)

# 去掉NA值
str_sort(c(NA, "1", NA), na_last = NA)
```

### `str_detect()` 检测是否匹配，返回T/F

```{r}
val <- c("abca4", 123, "cba2")

# 检查字符串向量，是否包括a
str_detect(val, "a")

# 检查字符串向量，是否以a为开头
str_detect(val, "^a")


# 检查字符串向量，是否以a为结尾
str_detect(val, "a$")
```

### `str_subset()` 返回成功匹配的字符串

```{r}
val <- c("abc", 123, "cba")

# 全文匹配
str_subset(val, "a")


# 开头匹配
str_subset(val, "^a")


# 结尾匹配
str_subset(val, "a$")
```

### `str_match()/str_extract()` 从字符串中提取匹配模式

主要与正则表达式配合使用

> str_match(string, pattern) 
> str_match_all(string, pattern) 

以字符串matrix格式返回

```{r}
val <- c("abc", 123, "cba")

# 匹配字符a，并返回对应的字符
str_match(val, "a")

# 匹配字符0-9，限1个，并返回对应的字符
str_match(val, "[0-9]")

# 匹配字符0-9，不限数量，并返回对应的字符
str_match(val, "[0-9]*")

# 返回matrix
str_match_all(val, "a")
str_match_all(val, "[0-9]")
```

> str_extract(string, pattern) 
> str_extract_all(string, pattern, simplify = FALSE)

simplify: TRUE返回matrix，FALSE返回列表

```{r}
val <- c("abca4", 123, "cba2")

# 返回匹配的数字
str_extract(val, "\\d")

# 返回匹配的字符
str_extract(val, "[a-z]+")

val <- c("abca4", 123, "cba2")
str_extract_all(val, "\\d")

str_extract_all(val, "[a-z]+")
```


### `word()` 从文本中提取单词（以单词为单位看待字符串）

> word(string, start = 1L, end = start, sep = fixed(" "))

start: 从第几个词开始。 end: 到第几个词结束。 sep: 分词间隔字符，默认为空格。

```{r}
val <- c("I am Conan.", "http://fens.me, ok")

# 默认以空格分割，取第一个位置的字符串
word(val, 1)
word(val, -1)
word(val, 2, -1)

# 以,分割，取第一个位置的字符串
val <- "111,222,333,444"
word(val, 1, sep = fixed(","))
word(val, 3, sep = fixed(","))
```

### `str_replace()` 字符串替换

> str_replace(string, pattern, replacement)  
> str_replace_all(string, pattern, replacement)  
> str_replace_na(string, replacement = "NA"), 将NA（默认）替换为'NA'

**参数 replacement 可以是一个函数，使替换的规则更加复杂**

```{r}
val <- c("abc", 123, "cba")

# 把目标字符串第一个出现的a或b，替换为-
str_replace(val, "[ab]", "-")

# 把目标字符串所有出现的a或b，替换为-
str_replace_all(val, "[ab]", "-")

# 把目标字符串所有出现的a，替换为被转义的字符
str_replace_all(val, "[a]", "\\")



pigIt <- function(string) {
  str_replace_all(string, "\\w+", function(word) {
    str_c(str_sub(word, 2), str_sub(word, 1, 1), "ay")
  })
}

library(testthat)
test_that("Sample Tests", {
  expect_equal(pigIt("Pig latin is cool"), "igPay atinlay siay oolcay")
  expect_equal(pigIt("Hello world !"), "elloHay orldway !")
})
```

### `str_locate()` 找到模式在字符串中的始末位置

> str_locate(string, pattern) str_locate_all(string, pattern)

```{r}
val <- c("abca", 123, "cba")

# 匹配a在字符串中的位置
str_locate(val, "a")

# 用向量匹配
str_locate(val, c("a", 12, "b"))

# 以字符串matrix格式返回
str_locate_all(val, "a")

# 匹配a或b字符，以字符串matrix格式返回
str_locate_all(val, "[ab]")
```

### `str_conv` 字符编码转换

> str_conv(string, encoding)

```{r}
# 把中文字符字节化
x <- charToRaw("你好")
x

# 默认win系统字符集为GBK，GB2312为GBK字集，转码正常
str_conv(x, "GBK")
str_conv(x, "GB2312")

# 转UTF-8失败
str_conv(x, "UTF-8")

# 把unicode转UTF-8
str_conv("\u5317\u4eac", "UTF-8")
```

### `str_glue()` 模板字符串

```{r}
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, %Y')}."
)
str_glue("My name is {name}, not {{name}}.")
```



## base::

### `chartr()` 字符替换

`chartr(old, new, x)`，非常好用的函数，相当于按一个哈希表进行字符转换

```{r chartr}
chartr(old = "a", new = "c", x = "a123")
# 注意，old和new参数可以都是字符串，index 对应的字符进行任意次数的替换
chartr("Tt", "Uu", "AtGCtttACC")
```

### 字符串分割

`strsplit(x, split, fixed = FALSE)`

```{r strsplit}
# fixed=F, 第2个参数为正则表达式。'.'可匹配除“\n”和"\r"之外的任何单个字符。
splited <- unlist(strsplit("a.b.c", "."))
splited
# fixed=T，第2个参数为文本字符串
splited <- unlist(strsplit("a.b.c", ".", fixed = T))
splited
```

### 字符串匹配

字符串匹配函数 grep(pattern, x, fixed=FALSE)和grepl()

```{r grep}
cstr <- c("b", "A", "c", "a.a")
# fixed=T，第1个参数为文本字符串
grep(".", cstr, fixed = TRUE)
# fixed=F，第1个参数为正则表达式
grep(".", cstr, fixed = F)
# grep仅返回匹配项的下标；而grepl返回逻辑向量表示有没有找到匹配
grepl(".", cstr, fixed = TRUE)
# 用于提取子集是一样的
cstr[grep(".", cstr, fixed = TRUE)]
cstr[grepl(".", cstr, fixed = TRUE)]
```

### 字符串替换

字符串替换函数 sub(pattern, replacement, x, fixed=FALSE)

```{r sub}
# fixed=F, 第1个参数为正则表达式，'\\s'表示空白
sub("\\s", ".", "Hello There")
# fixed=T, 第1个参数为文本字符串，在'Hello There'中找不到'\\s'
sub("\\s", ".", "Hello There", fixed = T)
# sub()与gsub()的区别，替换一次和替换任意次（只要匹配成功）
sub("e", "E", "Hello There", fixed = T)
gsub("e", "E", "Hello There", fixed = T)
```