在挖掘分析的过程当中对字符串的处理是极为重要的，且出现也较为频繁，R语言作为当前最为流行的开源数据分析和可视化平台，虽然文本的处理并不是它的强项, 但是R语言还是包含大量的字符串操作工具，本章着重整理了部分常用字符处理函数及其使用方法。
1) 字符长度统计
length(x)函数 — 返回向量x的长度，或者说向量中元素的个数；
nchar(x)函数 — 返回向量x中的每个元素的字符个数，对于非字符元素会得到不可预料的结果。
–举例1：
x
#返回3，向量x中共有3个元素
length(x)
#返回1 7 12，向量x中每个元素的字符个数
nchar(x)
–举例2：
#返回1，空向量长度为1
length("")
#返回0，空向量字符长度为0
nchar("")
#非字符元素NA，返回错误结果2
nchar(NA)
2) 字符大小写转换
toupper(x)函数 — 将字符矩阵x内各元素转化为大写形式；
tolower(x)函数 — 将字符矩阵x内各元素转化为小写形式；
casefold(x，upper = FALSE)函数 — 将字符矩阵x内各元素转化为大写或小写形式，默认为转换为小写，当upper =TRUE时转换为大写；
–举例1：
x
#转化x中的各元素为大写形式，NA依然返回NA
toupper(x)
#转化x中的各元素为小写形式，NA依然返回NA
tolower(x)
#转化x中的各元素为小写形式，默认upper = FALSE，NA依然返回NA
casefold(x)
#转化x中的各元素为大写形式，设置upper = TRUE，NA依然返回NA
casefold(x, upper =TRUE)
字符串连接是较为常见的字符操作，在此R提供了强大的paste函数，它不仅可以实现字符串的连接，也可以实现字符向量的连接，无论是字符向量还是字符串，在连接前paste会把对象首先转换为字符而后进行连接，另外，当向量连接时，较短的向量会循环使用。
1) paste 函数
基本语法:
paste (...,sep= " ", collapse =NULL)
参数sep表示连接的分隔符，默认为一个空格，参数collapse作为合并成一个字符串时的分隔符，详情请见以下应用实例：
–举例1：
x
paste(x, y)
#不设置sep，默认以空格分割
paste("A", 1:4)
#设置sep，去掉空格分隔符
paste("A", 1:4,sep= "")
–举例2：
#字符向量的连接,较短的字符循环被使用
paste(c("a", "b"), 1:3,sep= "")
–举例3：
#连接前隐式转换为字符串
name
age
person
#返回结果"NJc(1,3, 2)" "NJc(30, 20,10)"
paste("NJ", person,sep="")
注: 数据框内的字符串会默认转换为因子(依赖于stringsAsFactors参数的设置，默认为True，即字符会被转换为因子类型)，然后paste连接的时候会进行隐式转换，默认转换为字符型连接，所以使用paste函数时，有时候并不能得到想要的结果。
–举例4：
#使用collapse参数, collapse的使用可使连接后的字符组成一个字符串
#返回字符串A1,A2,A3,A4
paste("A", 1:4,sep="" ,collapse = ",")
2) paste0 函数
基本语法：
paste0(..., collapse = NULL)
参数意义paste与函数相同, 不同之处在于sep默认设置为空字符。
–举例1：
#结果中没有空格分隔符
paste0("A", 1:4)
3) sprintf函数
基本语法:
sprintf(fmt,...)
sprintf表示字符串“打印”，把若干元素按照给定的格式组合赋值给字符串。fmt表示包含格式字符的字符向量，sprintf中的参数会循环使用。
–举例1：
#以固定长度输出月份的名称，fmt被循环使用，长度不足在字符前面补空格
sprintf("%09s", month.name)
#以固定长度输出月份的名称，fmt被循环使用,长度不足在字符后面补空格
sprintf("%-9s", month.name)
–举例2：
#向量元素按顺序组合
sprintf(c("Name:%s", "Age: %s"), c("Kingsley", "30"))
–举例3：
#以指定格式输出圆周率
sprintf("%f",pi)
sprintf("%.3f",pi)
sprintf("%1.0f",pi)
sprintf("%5.1f",pi)
sprintf("%05.1f",pi)
sprintf("%+f",pi)
sprintf("%f", pi)
sprintf("%-10f",pi) # left justified
sprintf("%e",pi)
sprintf("%E",pi)
sprintf("%g",pi)
sprintf("%g", 1e6 * pi) # -> exponential
sprintf("%.9g",1e6 * pi) # -> "fixed"
sprintf("%G",1e-6 * pi)
4) cat函数
基本语法:
cat(... , file ="", sep = " ", fill = FALSE, labels = NULL,
append = FALSE)
cat函数用于连接字符串并输出到文件，默认file为空直接输出；sep表示连接的分隔符，默认为一个空格；fill逻辑值，为FALSE只有显式地使用“\n”才会换行输出，为TRUE只要达到选择宽度即可换行；labels为行标签，只在fill = TRUE时有效，若设定的行数小于实际行数，则会循环使用。append逻辑值，为FALSE会覆盖之前的输出，否则在原来内容后添加新输出。
–举例1：
#连接字符串，此处A不会循环使用
cat("A", 1:4, sep= " ")
–举例2：
#换行输出到文件abc.txt，每行都有相应的行标签
cat(paste(letters, 100*1:26), file = "abc.txt", fill = T, labels = paste0("{",1:10, "}:"))
R语言有多重方法判断特定元素(vector)在另一个元素(vector)中是否存在匹配的元素。下面逐一介绍各种方法：
1. match函数族
match函数族用于匹配字符时返回匹配或部分匹配的元素下标，匹配参数不支持正则表达式。
1) match函数
基本语法：
match(x, table,nomatch = NA_integer_, incomparables = NULL)
其中参数nomatch表示不匹配时的返回值(默认为NA，强制为integer型)，incomparables指定不能用来匹配的值(vector)，因此incomparables中配置的值，即使x在table中得到匹配也会由nomatch代替。match函数要求完全匹配。
–举例1：
#return 2，字符mn匹配字符向量第二个元素的值
match("mn",c("ab", "mn", "xy"), nomatch =NA)
–举例2：
#return 1，字符mn匹配字符向量第一以及第二个元素的值，返回第一个元素下标
match("mn",c("mn", "mn", "xy"), nomatch =NA)
–举例3：
#return NA，incomparables包含了字符值mn，因此即使匹配也返回NA
match("xy",c("ab", "mn", "xy"), nomatch =NA,incomparables = c("mn", "xy"))
函数%in%，实际可表示为match函数，不同的是返回值为逻辑向量
"%in%" 0
–举例1：
#返回长度为10的逻辑向量，存在的为TRUE，不存在为FALSE
1:10 %in%c(1,3,5,9)
–举例2：
#返回sstr中存在于26个字符中的元素，包括大小写
sstr
sstr[sstr %in%c(letters, LETTERS)]
2) pmatch函数
基本语法:
pmatch(x, table,nomatch = NA_integer_, duplicates.ok = FALSE)
其中参数nomatch表示不匹配时的返回值(默认为NA，强制为integer型)，
duplicates.ok表示table里面的元素是否可以适用多次。 pmatch函数是一个部分匹配函数, 依次从x里面挑出元素, 对照table进行匹配, 若匹配上则从table中剔除匹配上的值(部分匹配要求从元素的开始进行匹配，若x出现在table元素的中间不予匹配), 不再参与下次匹配, duplicate.ok可设置是否剔除; 对于某一个元素, 匹配一共分成三步：
l 如果可以完全匹配, 则认为匹配上了, 返回table中的位置;
l 不满足上述条件, 如果是唯一部分匹配, 则返回table中的位置;
l 不满足上述条件, 则认为没有值与其匹配上.
–举例1：
#return2，完成匹配第二个元素，忽略第一个元素的部分匹配
pmatch("me", c("mean", "me","mode"))
–举例2：
#return1，唯一部分匹配，返回匹配的元素下标
pmatch("me", c("mean", "mae","mode"))
–举例3：
#returnNA，部分匹配多个值返回NA
pmatch("m", c("mean", "median", "mode"))
–举例4：
#returnNA，mn出现在元素的中间不是从元素头开始，因此不予匹配
pmatch("mn", c("mean", "amnb", "mode"))
–举例5：
#duplicate.ok为FALSE，匹配后剔除，因此第一次完全匹配后table中的第二
#个元素被剔除，第二次只能取部分匹配的值，因此返回NA,2，1
pmatch(c("", "ab", "ab"), c("abc", "ab"), dup = FALSE)
–举例6：
#duplicate.ok为TRUE，table中元素可使用多次，因此第一次完全匹配后#table的第二个元素未被剔除，第二次认可使用，因此返回NA,2，2
pmatch(c("", "ab", "ab"), c("abc", "ab"), dup = FALSE)
基本语法:
charmatch(x,table, nomatch = NA_integer_)
与pmatch功能类似可用于部分匹配，如果同时存在完全匹配和部分匹配则取完全匹配值的下标，对于多个完全配合或者多个部分匹配的情况返回0值，没有匹配的返回nomatch所设置的值。
–举例1：
#return2，完成匹配第二个元素，忽略第一个元素的部分匹配
charmatch("me", c("mean", "me","mode"))
–举例2：
#return1，唯一部分匹配，返回匹配的元素下标
charmatch("me", c("mean", "mae","mode"))
–举例3：
#return 0，部分匹配多个值返回0
charmatch("m", c("mean", "median", "mode"))
–举例4：
#returnNA，mn出现在元素的中间不是从元素头开始，因此不予匹配
charmatch("mn", c("mean", "amnb", "mode"))
–举例5：
#匹配后元素仍可重复使用，return 0,2,2
charmatch(c("", "ab", "ab"), c("abc", "ab"))
2. grep函数族
与match函数不同，grep函数族可通过正则表达式在给定的对象中搜索文本。其中，grep输出向量的下标或值，grepl返回匹配与否的逻辑值。regexpr，gregexpr和regexec可以查找到某些字符在字符串中出现的具体位置和字符串长度信息，可以用于字符串的提取操作。
1) grep函数
基本语法：
grep(pattern, x, ignore.case= FALSE, perl = FALSE, value = FALSE,
fixed = FALSE, useBytes = FALSE, invert =FALSE)
grepl(pattern, x,ignore.case = FALSE, perl = FALSE,
fixed = FALSE, useBytes = FALSE)
grepRaw(pattern,x, offset = 1L, ignore.case = FALSE,value = FALSE, fixed = FALSE, all = FALSE,invert = FALSE)
pattern为字符串表示的正则表达式，或者字符串(fixed = TRUE)，ignore.case逻辑值，FALSE表示大小写敏感，TRUE不敏感；perl逻辑值，是否使用Perl风格的正则表达式，FALSE表示不使用，TRUE表示使用；value逻辑值，FALSE返回匹配元素的下标，TRUE返回匹配的元素值；fixed逻辑值，FALSE表示正则表达式匹配，TRUE为精确匹配；useBytes逻辑值，FALSE表示按字符匹配，TRUE表示按字节匹配；invert逻辑值，FALSE 查找匹配值，TRUE返回不匹配元素下标或值(根据value值)；offset指定匹配开始位置，all逻辑值，TRUE返回所有匹配值，FALSE返回第一个匹配值。
–举例1：
#查找含有字符o或者r的字符串，返回匹配的下标
grep("[or]",c("Tom", "Jerry", "Mickey"))
#查找含有字符o或者r的字符串，返回不匹配的下标
grep("[or]",c("Tom", "Jerry", "Mickey"), invert = TRUE)
#点好(.)匹配任意字符，返回下标
grep("e.r",c("pear", "cherry", "apple"))
#点好(.)匹配任意字符,value设置为TRUE，返回匹配的值
grep("e.r",c("pear", "cherry", "apple"), value = TRUE)
#$匹配一个字符串的结尾，返回以y结尾的字符串
grep("y$",c("year", "Jerry", "Mickey"))
#^匹配一个字符串的开始，返回以y开始的字符串
grep("^y",c("year", "Jerry", "Mickey"))
#匹配以c开头(不一定要求是字符串第一个字符)，接着方括号中任意一个字符，最
#后以t结尾
grep("c[aeiou]t",c("cat", "pcut", "apple"))
#[^a]表示匹配任意不是a的元素
grep("c[^a]t",c("cat", "pcut", "apple"))
#匹配a或者u
grep("c(a|u)t",c("cat", "pcut", "apple"))
#匹配字符串pp，{n}表示匹配n个字符
grep("ap{2}",c("cat", "pcut", "apple"))
#匹配字符串anan，{n}表示匹配n个字符
grep("(an){2}",c("cat", "pcut", " banana"))
#?匹配前面的子表达式零次或一次
grep("c(a)?t",c("cat", "pct", "apple"))
#*匹配前面的子表达式任意次,可匹配任意次的c和a
grep("ca*t",c("cat", "pct", "cct", "caaaat"))
#+匹配前面的子表达式一次或多次(大于等于1),只能匹配a
grep("ca+t",c("cat", "pt", "cct", "caaaat"))
–举例2：
#查找含有字符o或者r的字符串，返回与向量长度相同的逻辑向量
grepl("[or]",c("Tom", "Jerry", "Mickey"))
–举例3：
#返回第一次出现o或者r的下标
grepRaw("[or]","Tomorrow")
#设置all = TRUE，返回所有的o和r的位置下标
grepRaw("[or]","Tomorrow", all = TRUE)
#从位置3开始向后搜索匹配
grepRaw("[or]","Tomorrow", all = TRUE, offset = 3)
注意: 若原字符为非字节形式，会强制使用charToRaw先字节化。例如 :
charToRaw("Tomorrow")
2) regexpr、gregexpr和regexec函数
返回匹配结果的具体位置以及字符串长度信息，可以用于字符串的提取操作。
基本语法：
regexpr(pattern,text, ignore.case = FALSE, perl = FALSE,
fixed = FALSE, useBytes = FALSE)
gregexpr(pattern,text, ignore.case = FALSE, perl = FALSE,
fixed = FALSE, useBytes = FALSE)
regexec(pattern,text, ignore.case = FALSE, fixed = FALSE,
useBytes =FALSE)
–举例1：
#返回匹配向量包括字符的位置及匹配长度(只匹配第一次出现的)，不匹配返回-1
regexpr("ca*t",c("cat", "pct", "cctdcat", "caaaat","ddd"))
#返回匹配列表包含字符的位置及匹配长度(匹配多次)，不匹配字符返回-1
gregexpr("ca*t",c("cat", "pct", "cctdcat", "caaaat","ddd"))
#返回匹配列表包含字符的位置及匹配长度(只匹配第一次出现的)，不匹配返回-1
regexec("ca*t",c("cat", "pct", "cctdcat", "caaaat","ddd"))
regmatches函数，可以提取regexpr,gregexpr或regexec函数中匹配或者不匹配(invert = TRUE)的字符
基本语法：
regmatches(x, m,invert = FALSE)
–举例1：
#提取使用regexpr匹配的实际字符
x
m
regmatches(x, m)
根据广义Levenshtein编辑距离进行字符串模糊匹配(adist函数可用于计算Levenshtein编辑距离)。
基本语法 ：
agrep(pattern, x,max.distance = 0.1, costs = NULL,
ignore.case = FALSE, value = FALSE, fixed= TRUE,
useBytes = FALSE)
agrepl(pattern,x, max.distance = 0.1, costs = NULL,
ignore.case = FALSE, fixed = TRUE,useBytes = FALSE)
max.distance表示允许的最大Levenshtein编辑距离。
–举例1：
#返回最大编辑距离小于等于3的字符值
#返回1,2
agrep("lasy",c("1 lazy", "lmansky", "1 LAZY"), max = 3)
#返回"1 lazy"
agrep("lasy",c("1 lazy", "lmansky", "1 LAZY"), max = 2, value= T)
–举例2：
#返回匹配的逻辑向量
agrepl("lasy",c("1 lazy", "lmansky", "1 LAZY"), max = 3)
1. 字符串提取
以下函数可用于字符串提取，同时substr和substring也可用于字符串替换。
1) substr函数
基本语法:
substr(x, start,stop)
对字符串x截取从start到stop的子字符串。
–举例1：
#Return:jing，截取字符串第4位到第7为的字符
substr("Nanjing", 4, 7)
#Return:jing，截取字符串第4位到第10为的字符,stop超出字符长度，
#只取值到字符末尾
substr("Nanjing", 4, 10)
#Return:空字符，start超出字符串长度
substr("Nanjing", 8, 10)
–举例2：
#截取字符向量，对于位置向量长度不足会循环使用
#位置向量为1：4, 2:5, 3:4, 1:5，两个位置向量都循环取值
substr(rep("abcdef", 4), 1:3, 4:5)
–举例3：
#替换原字符串1-3的字符
add
substr(add, 1, 3)
2) substring函数
基本语法:
substring(text,first, last = 1000000L)
对字符串x截取从first到last的子字符串，last默认值为1000000，可以不传参。
–举例1：
#Return:jing，截取字符串第4位到第7为的字符
substring("Nanjing", 4, 7)
#Return:jing，截取字符串第4位到末尾的子字符串，未设置last取默认值
substring("Nanjing", 4)
–举例2：
#下标向量循环使用截取字符串
substring("Nanjing", 1:2, 1:6)
#未设置last截取字符串
substring("Nanjing", 1:6)
–举例3：
#替换原字符串1-3的字符
add
substring(add, 1, 3)
3) strtrim函数
基本语法:
strtrim(x,width)
对字符串x从开头截取指定width的子字符串，参数均可循环使用。对于中文字符，一个字符的长度为2，因此width也要设置为2倍宽度。
–举例1：
#Return:Nan，从头开始截取定宽字符
strtrim("Nanjing", 3)
–举例2：
#Return:字符，中文字符宽度需设置为2倍
strtrim("字符操作函数",4)
2. 字符串替换
sub和gsub为字符串替换函数，通过正则表达式设置灵活的匹配规则，返回被替换后的字符串，两者唯一的差别在于前者匹配第一次符合模式的字符串，后者匹配所有符合模式的字符串，也就是说在替换的时候前者只替换第一次符合的，后者可替换所有符合的。
1) sub和gsub函数
sub和gsub函数用于字符串替换，其中sub只替换第一次匹配的字符，而gsub会替换所有满足条件的匹配。由于R语言操作都是传值不传址，所以替换操作只是替换了原字符向量的copy，如果完全替换还需要再通过赋值操作。
基本语法：
sub(pattern,replacement, x, ignore.case = FALSE, perl = FALSE,
fixed = FALSE, useBytes = FALSE)
gsub(pattern,replacement, x, ignore.case = FALSE, perl = FALSE,
fixed = FALSE, useBytes = FALSE)
replacement参数表示需要替换的内容。
–举例1：
#以字符www替换第一次匹配的字符
sub("ca*t","www", c("cat", "pct", "cctdcat","caaaat", "ddd"))
#以字符www替换所有匹配的字符
gsub("ca*t","www", c("cat", "pct", "cctdcat", "caaaat","ddd"))
2) chartr函数
基本语法：
chartr(old, new,x)
把字符串x中的字符按照old到new进行替换，字符串old和new要求长度一致，且按顺序匹配替换。
–举例1：
#替换字符一一对应进行映射
chartr("Nan","Bei", "Nanjing")
–举例2：
#替换过程同时生效，由于原字符不存在B，因此不会进行B->F转换
chartr("NB","BF", "Nanjing")
3. 字符串拆分
基本语法：
strsplit(x,split, fixed = FALSE, perl = FALSE, useBytes = FALSE)
strsplit根据split拆分字符串x，并返回子字符串组成的长度与x相同的列表, 分隔符split包括正则表达式，当fixed= TRUE时，需要精确匹配，为FALSE(默认)，则使用正则表达式匹配， 除非使用反斜杠(\)转义。perl用于判断是否使用更强大的perl正则表达式，useBytes = TRUE 表示byte-by-byte按字节匹配， FALSE为character-by-character字符匹配(默认)。
–举例1：
#以分隔符-分割字符串
strsplit("JiangSu-Nanjing-Gaoxin","-")
–举例2：
#点好(.)为正则表达式表示任意字符,因此不能正确分割字符串
strsplit("JiangSu.Nanjing.Gaoxin",".")
#设置fixed为TRUE，精确匹配点好
strsplit("JiangSu.Nanjing.Gaoxin",".", fixed = TRUE)
#使用反斜杠(\)转义
strsplit("JiangSu.Nanjing.Gaoxin","\\.")
#使用通配符[]，表示含有点号的字符
strsplit("a.b.c","[.]")
–举例3：
#以下三种情况相同，把字符串分解为一个一个单个字符
strsplit("JiangSu-Nanjing-Gaoxin",NULL)
strsplit("JiangSu-Nanjing-Gaoxin","")
strsplit("JiangSu-Nanjing-Gaoxin",character(0))
–举例4：
#\s表示空白字符(包括空格、制表符、换行符等)
strsplit("JiangSuNanjing Gaoxin", "\\s")
strsplit("JiangSu\nNanjing\nGaoxin","\\s")
–举例5：
#使用分隔符”-”,对字符向量分解
person
strsplit(person,"-")
字符编码即编码字符集和实际存储数值之间的转换关系。字符集规定了某个文字对应的二进制数字存放方式(编码)和某串二进制数值代表了哪个文字(解码)的转换关系。R语言提供的一些字符编码函数。
1) Encoding函数
Encoding函数用于读取和设置字符向量的编码。R字符串可以使用包括 "latin1" ， "UTF-8" 或 "bytes"的编码格式。由于ASCII 字符串对各种编码表示的形式相同，所以Encoding获取的编码方式为unknown。
–举例1：
x
#字符编码为unknown
Encoding(x)
#设置字符编码为latin1
Encoding(x)
2) iconv函数
字符编码转换，转换过程中并不会做太多的校验，因此放源编码不合法时，常常不能正确转换，基本语法:
iconv(x, from ="", to = "", sub = NA, mark = TRUE, toRaw = FALSE)
from为源编码；to为目标编码；sub用于替换不能转换的字节(默认为NA)，如果本身为字节类型，则使用16进制字节形式替换。mark逻辑值，指明返回的字符向量是否申明编码类型，默认为TRUE即返回编码类型；toRaw逻辑值，指明是返回字符向量还是字节向量。
–举例1：
x
#设置字符编码为latin1
Encoding(x)
#转换latin1字符编码为UTF-8
iconv(x, "latin1","UTF-8")
–举例2：
x
Encoding(x)
#转换为字节型输出
iconv(x, "latin1","UTF-8", toRaw = T)
charToRaw(iconv(x,"latin1", "UTF-8"))
注意:
iconvlist() 可用于输出不同环境支持的编码类型
从当前语言环境选择合适的编码名称。
localeToCharset(locale =Sys.getlocale("LC_CTYPE"))
相较于R语言基本的字符操作，stringr包提供了更加灵活易用的字符操作方式。
1. 统计匹配的字符数
基本语法：
str_count(string,pattern = "")
–举例1：
x
#统计字符向量中每个字符串中字符R的个数
str_count(x,pattern = "R")
–举例2：
#不能正确统计元字符的个数
str_count(c("a.","...", ".a.a"), ".")
#使用fixed函数
str_count(c("a.","...", ".a.a"), fixed("."))
#使用反斜杠转义
str_count(c("a.","...", ".a.a"), "\\.")
#使用[.]同样有效
str_count(c("a.","...", ".a.a"), "[.]")
–举例3：
#使用空字符串返回每个字符串的字符个数，相当于nchar
x
str_count(x,pattern = "")
2. 字符长度统计
基本语法：
str_length(string)
–举例1：
x
#统计每个字符串的字符个数，相当于nchar,不同的是NA不会计数依然返回NA
str_length(x)
3. 字符串转换
基本语法：
str_to_upper(string,locale = "")
str_to_lower(string,locale = "")
str_to_title(string,locale = "")
–举例1：
x
#转换为全小写，NA依然返回NA
str_to_lower(x)
#转换为全大写，NA依然返回NA
str_to_upper(x)
#转换为首字符大写，NA依然返回NA
str_to_title(x)
4. 字符串连接
基本语法：
str_c(..., sep ="", collapse = NULL)
参数sep表示连接的分隔符，默认为空字符，参数collapse作为合并成一个字符串时的分隔符。
–举例1：
x
str_c(x, y)
str_c(x, y, sep= ",")
–举例2：
#以逗号连接为一个字符串
str_c("A",1:4, collapse = ",")
–举例3：
#NA不参与连接，依然输出NA
str_c(c("A","B", NA, "C"), 1:4)
5. 字符串匹配
1) str_match函数
基本语法：
str_match(string,pattern)
str_match_all(string,pattern)
–举例1：
#返回实际匹配字符组成的字符矩阵，只包含第一个匹配的字符,不匹配值返回NA
str_match(c("pear,ear","cherry", "apple"), "e.r")
–举例2：
#返回字符矩阵组成的list，包含所有匹配的字符，不匹配值返回空字符
str_match_all(c("pear,ear","cherry", "apple"), "e.r")
2) str_extract函数
基本语法：
str_extract(string,pattern)
str_extract_all(string,pattern, simplify = FALSE)
simplify默认值为FALSE，返回字符向量组成的列表，为TRUE则返回字符矩阵。
–举例1：
#返回实际匹配字符组成的字符向量，只包含第一个匹配的字符,不匹配值返回NA
str_extract(c("pear,ear","cherry", "apple"), "e.r")
–举例2：
#匹配所有满足条件字符，不匹配值返回空字符
#simplify = FALSE(默认)，返回字符向量组成的list
str_extract_all(c("pear,ear","cherry", "apple"), "e.r")
#simplify= TRUE，返回字符向量组成的matrix
str_extract_all(c("pear,ear", "cherry","apple"), "e.r", simplify = TRUE)
3) str_detect函数
基本语法：
str_detect(string,pattern)
返回与string等长的逻辑向量，类似于grepl。
–举例1：
fruit
#返回与string向量长度相同的逻辑矩阵，包含所有匹配的元素
str_detect(fruit,"a")
str_detect(fruit,"^a")
str_detect(fruit,"a$")
str_detect(fruit,"b")
str_detect(fruit,"[aeiou]")
1) str_subset函数
基本语法：
str_subset(string,pattern)
返回匹配的字符串值，类似于grep(pattern, x,value = TRUE)。
–举例1：
fruit
#返回匹配的所有字符串值
#相当于fruit[str_detect(fruit,"[lr]")]
str_subset(fruit,"[lr]")
2) str_locate函数
基本语法：
str_locate(string,pattern
str_locate_all(string,pattern)
查找匹配的字符，返回数值矩阵，第一列为匹配字符的起始位置，第二列为终止位置。str_locate_all返回由数值矩阵组成的列表。
–举例1：
#返回第一个匹配字符的位置矩阵，不匹配值和NA值返回NA
str_locate(c("pear,ear","cherry", "apple", NA), "e.r")
–举例2：
#返回全部匹配字符位置矩阵组成的列表，不匹配值返回空，NA依然返回NA
str_locate_all(c("pear,ear","cherry", "apple", NA), "e.r")
6. 字符串复制
基本语法：
str_dup(string, times)
–举例1：
#按位置复制字符串，NA不会复制
str_dup(c("pear,ear","cherry", "apple", NA), c(1:4))
7. 字符串补充
基本语法：
str_pad(string,width, side = c("left", "right", "both"), pad =" ")
string为字符串或字符串向量；width为字符串填充后的长度；side为填充方向，both两边填充，left左边填充，right右边填充；pad: 用于填充的字符，默认为空格。
–举例1：
#两边填充字符*直到宽度为10
str_pad(c("pear,ear","cherry", "apple", NA), 10, "both", pad ="*")
8. 字符串去空格
基本语法：
str_trim(string, side = c("both","left", "right"))
去除包括空格，\t和\n等字符。
–举例1：
#删除字符串左边的空格
str_trim(" \t\npear \t \n ", "left")
–举例2：
#删除字符串右边的空格
str_trim(" \t\npear \t \n ", "right")
–举例3：
#删除字符串两边的空格，不设置side默认为both
str_trim(" \t\npear \t \n ", "both")
9. 字符串截取/替换/拆分
1) str_sub函数
基本语法：
str_sub(string, start = 1L,end = -1L)
str_sub(string, start = 1L,end = -1L)
对字符串string截取从start到end的子字符串。
–举例1：
#Return:jing，截取字符串第4位到第7为的字符
str_sub("Nanjing", 4, 7)
#Return:jing，截取字符串第4位到第10为的字符,stop超出字符长度，
#只取值到字符末尾
str_sub("Nanjing", 4, 10)
#Return:空字符，start超出字符串长度
str_sub("Nanjing", 8, 10)
–举例2：
#截取字符向量，对于位置向量长度不足会循环使用
#位置向量为1：4, 2:5, 3:4, 1:5，两个位置向量都循环取值
str_sub(rep("abcdef", 4), 1:3, 4:5)
–举例3：
#end可以设置为负值
str_sub("Nanjing", 3, -2)
–举例4：
#替换原字符串1-3的字符
add
str_sub(add, 1, 3)
2) word函数
基本语法:
word(string,start = 1L, end = start, sep = fixed(" "))
用于从语句中提取单词(字符串)。string为字符串或字符串向量；start为数值向量给出提取的开始位置；end为数值向量给出提取的结束位置；sep为单词间分隔符。
–举例1：
fruit
#默认以空格为分隔符，取第一个位置的字符
word(fruit, 1)
#默认以空格为分隔符，取第二个位置的字符
word(fruit, 2)
word(fruit, -1)
–举例1：
fruit
#以点好.为分隔符，取第一个位置的字符
word(fruit, 1,sep = fixed("."))
3) str_replace函数
基本语法：
str_replace(string, pattern,replacement)
str_replace_all(string,pattern, replacement)
str_replace_na(string,replacement = "NA")
找到匹配的字符，并用给定的字符串进行替换。
–举例1：
fruit
#替换字符串中第一次出现的a或p
str_replace(fruit, "[ap]", "*")
#替换字符串中所有的a或p
str_replace_all(fruit, "[ap]", "*")
–举例2：
#替换NA为NA字符串
str_replace_na(c(NA, "NA", "apple"))
#替换NA为字符*
str_replace_na(c(NA, "NA", "apple"), "*")
4) str_split函数
基本语法：
str_split(string, pattern, n= Inf)
str_split_fixed(string,pattern, n)
对字符串进行拆分，n为分割的字符串个数。
–举例1：
#使用反斜杠(\)转义
str_split("JiangSu.Nanjing.Gaoxin","\\.")
#分解为两个字符串
str_split("JiangSu.Nanjing.Gaoxin","\\.", 2)
#使用通配符[]，表示含有点号的字符
str_split("a.b.c","[.]")
#设置fixed为TRUE，精确匹配点好
str_split_fixed("JiangSu.Nanjing.Gaoxin","\\.", 3)
–举例3：
#把字符串分解为一个一个单个字符，不支持NULL以及character(0)
str_split("JiangSu-Nanjing-Gaoxin","")
–举例4：
#使用分隔符”-”,对字符向量分解
person
#返回list对象
str_split(person,"-")
10. 字符串编码转换
基本语法：
str_conv(string, encoding)
–举例1：
x
#设置字符编码为latin1
str_conv(x,"latin1")
11. 字符串值排序
基本语法：
str_order(x, decreasing =FALSE, na_last = TRUE, locale = "", ...)
str_sort(x, decreasing =FALSE, na_last = TRUE, locale = "", ...)
decreasing逻辑值，指定排序方向，默认为升序；na_last逻辑值，NA值的存放位置， TRUE放到最后，FALSE放到最前，NA表示过滤NA值排序；locale设置按那种语言习惯排序。
–举例1：
fruit
#按英文排序
str_sort(fruit,locale = "en")
#返回排序后的下标
str_order(fruit,locale = "en")
#过滤NA后排序
str_sort(fruit,locale = "en", na_last = NA)
12. 字符串输出
基本语法：
str_wrap(string, width = 80,indent = 0, exdent = 0)
string为字符串或字符串向量；width设置行宽；indent设置段落首行的缩进值；exdent设置段落非首行的缩进值。类似于strwrap函数。
–举例1：
thanks_path
thanks
thanks
#默认输出
cat(str_wrap(thanks),"\n")
#设置宽度为40
cat(str_wrap(thanks,width = 40), "\n")
#设置宽度为60，首行缩进2个字符
cat(str_wrap(thanks,width = 60, indent = 2), "\n")
#设置宽度为60，非首行缩进2个字符
cat(str_wrap(thanks,width = 60, exdent = 2), "\n")
#设置宽度为0，每个单词为一行输出
cat(str_wrap(thanks,width = 0, exdent = 2), "\n")
)
)
显卡玩游戏性能更高...)
