在挖掘分析的過程當中對字符串的處理是極為重要的，且出現也較為頻繁，R語言作為當前最為流行的開源數據分析和可視化平臺，雖然文本的處理并不是它的強項, 但是R語言還是包含大量的字符串操作工具，本章著重整理了部分常用字符處理函數及其使用方法。
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)
字符串連接是較為常見的字符操作，在此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, "}:"))
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)
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,"-")
字符編碼即編碼字符集和實際存儲數值之間的轉換關系。字符集規定了某個文字對應的二進制數字存放方式（編碼）和某串二進制數值代表了哪個文字（解碼）的轉換關系。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"))
相較于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")
