【R语言】字符串处理

        在挖掘分析的过程当中对字符串的处理是极为重要的，且出现也较为频繁，R语言作为当前最为流行的开源数据分析和可视化平台，虽然文本的处理并不是它的强项, 但是R语言还是包含大量的字符串操作工具，本章着重整理了部分常用字符处理函数及其使用方法。

5.1 基本字符操作

1） 字符长度统计

length(x)函数 — 返回向量x的长度，或者说向量中元素的个数；

nchar(x)函数  — 返回向量x中的每个元素的字符个数，对于非字符元素会得到不可预料的结果。

–       举例1：

x <-c("R", "Rstudio", "Revolution R")

# 返回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 <- c("r", "rstudio", "revolutionR", NA)

# 转化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)

5.2 字符串连接

字符串连接是较为常见的字符操作，在此R提供了强大的paste函数，它不仅可以实现字符串的连接，也可以实现字符向量的连接，无论是字符向量还是字符串，在连接前paste会把对象首先转换为字符而后进行连接，另外，当向量连接时，较短的向量会循环使用。

1） paste 函数 

基本语法:

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

参数sep表示连接的分隔符，默认为一个空格，参数collapse作为合并成一个字符串时的分隔符，详情请见以下应用实例：

–        举例1：

x <- "Hello"; y <- "world"

paste(x, y)

#不设置sep，默认以空格分割

paste("A", 1:4) 

#设置sep，去掉空格分隔符

paste("A", 1:4, sep = "")

 

–        举例2：

#字符向量的连接,较短的字符循环被使用

paste(c("a", "b"), 1:3, sep = "")

 

–        举例3：

#连接前隐式转换为字符串

name <- c("Kingsley", "William","Tom");

age <- c(30, 20, 10); 

person <- data.frame(name, age)

#返回结果"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, "}:"))

5.3 字符匹配

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%"<- function(x, table) match(x, table, nomatch = 0) > 0

–       举例1：

#返回长度为10的逻辑向量，存在的为TRUE，不存在为FALSE

1:10 %in%c(1,3,5,9)

 

–       举例2：

#返回sstr中存在于26个字符中的元素，包括大小写

sstr <-c("c","ab","B","bba","c",NA,"@","bla","a","Ba","%")

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)

 

3)    charmatch 函数

基本语法:

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 <- c("cat","pct", "cctdcat", "caaaat", "ddd")

m <-regexpr("ca*t", x)

regmatches(x, m)

 

3） agrep函数

根据广义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)

5.4 字符串提取/替换/拆分

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 <- "Nanjing"

substr(add, 1, 3) <- "Bei"

 

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 <- "Nanjing"

substring(add, 1, 3) <- "Bei"

 

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 <-c("Tom-30", "Jerry-20", "Bob-18")

strsplit(person,"-")

5.5 字符编码转换

字符编码即编码字符集和实际存储数值之间的转换关系。字符集规定了某个文字对应的二进制数字存放方式（编码）和某串二进制数值代表了哪个文字（解码）的转换关系。R语言提供的一些字符编码函数。

1)    Encoding函数

Encoding函数用于读取和设置字符向量的编码。R字符串可以使用包括 "latin1" ， "UTF-8" 或 "bytes"的编码格式。由于ASCII 字符串对各种编码表示的形式相同，所以Encoding获取的编码方式为unknown。

–       举例1：

x <-"fa\xE7ile"

#字符编码为unknown

Encoding(x)

#设置字符编码为latin1

Encoding(x) <-"latin1"

 

2)    iconv函数

字符编码转换，转换过程中并不会做太多的校验，因此放源编码不合法时，常常不能正确转换，基本语法:

iconv(x, from ="", to = "", sub = NA, mark = TRUE, toRaw = FALSE)

from为源编码；to为目标编码；sub用于替换不能转换的字节（默认为NA），如果本身为字节类型，则使用16进制字节形式替换。mark逻辑值，指明返回的字符向量是否申明编码类型，默认为TRUE即返回编码类型；toRaw逻辑值，指明是返回字符向量还是字节向量。

–       举例1：

x <-"fa\xE7ile"

#设置字符编码为latin1

Encoding(x) <-"latin1"

#转换latin1字符编码为UTF-8

iconv(x, "latin1","UTF-8")

–       举例2：

x <-"fa\xE7ile"

Encoding(x) <-"latin1"

#转换为字节型输出

iconv(x, "latin1","UTF-8", toRaw = T)

charToRaw(iconv(x,"latin1", "UTF-8"))

 

注意:

iconvlist() 可用于输出不同环境支持的编码类型

从当前语言环境选择合适的编码名称。

localeToCharset(locale =Sys.getlocale("LC_CTYPE"))

5.6 字符串处理包stringr

相较于R语言基本的字符操作，stringr包提供了更加灵活易用的字符操作方式。

1.    统计匹配的字符数

基本语法：

str_count(string,pattern = "")

–       举例1：

x <-c("R", "Rstudio", "Revolution R")

#统计字符向量中每个字符串中字符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 <-c("R", "Rstudio", "Revolution R")

str_count(x,pattern = "")

 

2.    字符长度统计

基本语法：

str_length(string)

–       举例1：

x <-c("R", "Rstudio", "Revolution R", NA)

#统计每个字符串的字符个数，相当于nchar,不同的是NA不会计数依然返回NA

str_length(x)

 

3.    字符串转换

基本语法：

str_to_upper(string,locale = "")

str_to_lower(string,locale = "")

str_to_title(string,locale = "")

–       举例1：

x <-c("r", "rstudio", "revolution R", NA)

#转换为全小写，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 <-"Hello"; y <- "world"

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 <-c("apple", "banana", "pear","pinapple")

#返回与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 <-c("apple", "banana", "pear","pinapple")

#返回匹配的所有字符串值

#相当于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) <- value

对字符串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 <- "Nanjing"

str_sub(add, 1, 3) <- "Bei"

2)    word函数

基本语法:

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

用于从语句中提取单词(字符串)。string为字符串或字符串向量；start为数值向量给出提取的开始位置；end为数值向量给出提取的结束位置；sep为单词间分隔符。

–       举例1：

fruit <-c("apple red", "banana yellow", NA)

#默认以空格为分隔符，取第一个位置的字符

word(fruit, 1)

#默认以空格为分隔符，取第二个位置的字符

word(fruit, 2)

word(fruit, -1)

 

–       举例1：

fruit <-c("apple.red", "banana.yellow", NA)

#以点好.为分隔符，取第一个位置的字符

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 <- c("apple", "banana", "pear", "pinapple", NA)

#替换字符串中第一次出现的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 <-c("Tom-30", "Jerry-20", "Bob-18")

#返回list对象

str_split(person,"-")

 

10.  字符串编码转换

基本语法：

str_conv(string, encoding)

–       举例1：

x <-"fa\xE7ile"

#设置字符编码为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 <- c("pear","apple", "pinapple", "banana", NA)

#按英文排序

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<- file.path(R.home("doc"), "THANKS")

thanks <-str_c(readLines(thanks_path), collapse = "\n")

thanks <-word(thanks, 1, 3, fixed("\n\n"))

#默认输出

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")