R String Manipulation Functions – I bet you will master its Usage!

FREE Online Courses: Your Passport to Excellence - Start Now

In this blog on R string manipulation, we are going to cover the R string manipulation functions. There are 8 string manipulation functions in R. We will discuss all the R string manipulation functions in this R tutorial along with their usage.

So, let’s quickly start the tutorial.

What is String Manipulation in R?

Generic programming in an OpenCL program restricts to using a string manipulation mechanism, where the program is constructed as a string at runtime. Then, it is passed to the OpenCL driver fronted, that will finally compile and build the kernel at runtime. Command group that call kernels can also be templated, allowing for a complex position of functors and types.

Here are the functions available for string manipulation in R:

  • grep()
  • nchar()
  • paste()
  • sprintf()
  • substr()
  • strsplit()
  • regex()
  • gregexpr()

Wait! Have you checked – Input-Output Features in R Programming

R String Manipulation Functions

Now, we will understand the R String manipulation functions with their usage.

1. grep()

It is used for pattern matching and replacement. grep, grepl, regexpr, gregexpr and regexec search for matches with argument pattern within each element of a character vector. Here we subsitute the first and other matches with sub and gsub.  sub and gsub perform replacement of the first and all matches.


Utilities, character.


grep("b+", c("abc", "bda", "cca a", "abd"), perl=TRUE, value=FALSE)


grep function


  • pattern – Character string containing a regular expression that should match with the given character vector.
  • x, text – It represents a character vector where matches are sought.
  • ignore.case – If FALSE, the pattern matching is case sensitive and if TRUE, a case will be ignored during matching.
  • value – If a vector containing the indices of the matches determined by grep will return, then it is FALSE. If a vector containing the matching elements themselves will return, then it is TRUE.
  • fixed – If TRUE, then a pattern is a string that should match as it is and it will override all conflicting arguments.
  • useBytes – If TRUE, then the matching will be done byte-by-byte rather than character-by-character.
  • invert – If TRUE, then it will return indices or values for elements that do not match.
  • replacement – A replacement for the matched pattern in sub and gsub.

2. nchar()

With the help of this function, we can count the characters.  This function consists of a character vector as its argument which then returns a vector comprising of different sizes of the elements of x. nchar is the fastest way to find out if elements of a character vector are non-empty strings or not.




> str <- "Big Data at DataFlair"
> nchar(str)


nchar function in R - String Manipulation


  • x – Character vector or a vector will be restricted to a character vector. Providing factor as input returns an error.
  • allowNA – This is a logical attribute that decides whether NA or a byte encoded string should be returned instead of an error.
  • type – Character string: partial matching to one of c(“bytes”, “chars”, “width”).
  • keepNA – It is a logical attribute that decides whether to return NA where the value of variable x is NA.  This attribute has a default value of TRUE.

Do you know about R Factor Functions

3. paste()

We can concatenate n number of strings using the paste() function.




> #Author DataFlair
> paste("Hadoop", "Spark", "and", "Flink")


paste function - R String Manipulation


  • … – One or more R objects will convert to character vectors.
  • sep –  Using this, we can separate the terms and not the NA character.
  • collapse –  This attribute specifies an optional character for separating the results and not any type of NA character.

4. sprintf()

This function makes of the formatting commands that are styled after C. 


print, character


sprintf("%s scored %.2f percent", "Matthew", 72.3)


sprintf function - String Manipulation


  • fmt – This type of a character vector of format strings has a size fixed of up to 8192 bytes.
  • … – Values will pass into fmt.
  • domain – See gettext.

It’s time to revise the Vector Functions in R

5. substr()

It is the substrings of a character vector. The extractor replaces substrings in a character vector.




#Author DataFlair
> num <- "12345678"
> substr(num, 4, 5)
> substr(num, 5, 7)


substr function - String Manipulation


  • x, text – A character vector.
  • start, first – An integer. The first element that should be replaced.
  • stop, last – An integer. The last element that should be replaced.
  • value – A character vector which is recycled if necessary.

6. strsplit()




> #Author DataFlair
> str = "Splitting sentence into words"
> strsplit(str, " ")


strsplit function


  • x – It is a character vector, each element of which is to be split.
  • split – It is a character vector containing regular expression(s) for splitting.
  • fixed – If it is TRUE, then it will match the split exactly.
  • useBytes – If this argument is set to TRUE, then matching is performed byte-by-byte instead of character-by-character. Furthermore, inputs that contain the encodings do not undergo any conversion.

Gain Expertise in Numeric and Character Functions in R

7. regexpr()

It represents a character vector where matches are sought.


str = "Line 129: O that this too too solid flesh would melt,Thaw, and resolve itself into a dew!"
out <- regexpr("\\d+",str)

Code Display:

Regexpr Input - String Manipulation


Regexpr Output


  • …. – Passed to paste0.
  • x – A regex.

8. gregexpr()

An extension of the base function, this function retrieves the matching substrings. 




str = "Line 129: O that this too too solid flesh would melt,Thaw, and resolve itself into a dew!"
out <- gregexpr("\\d+",str)

Code Display:

gregexpr function - String Manipulation


gregexpr output


  • pattern – Character string containing a regular expression that should match with the given character vector.
  • text – This object will pose the restriction from as.character to a character one.
  • ignore.case – If it is FALSE, then the pattern matching is case sensitive but if TRUE, then the case will be ignored during matching.
  • fixed – If it is TRUE, then a pattern is a string that should match as it is. It overrides all conflicting arguments.
  • useBytes – If it is TRUE, then the matching should be done byte-by-byte rather than character-by-character.
  • extract – If logical indicating matches, then substrings needs to be extracted and returned.

These are the function used in R string manipulation.

Regular Expressions in R

A set of strings will define as regular expressions. We use two types of regular expressions in R, extended regular expressions (the default) and Perl-like regular expressions used by perl = TRUE.

Regular Expression Syntax

It specifies the characters to seek out, with information about repeats and location within the string. You can practice it with the help of metacharacters that have a specific meaning: $, *, +, ?, [ ], ^ , { }, |, ( ), \, .

Use of String Utilities in the edtdbg Debugging Tool

The internal code of the edtdbg debugging tool makes heavy use of string utilities. A typical example of such usage is the dgbsendeditcmd() function:

# send command to editor</span>
dbgsendeditcmd <- function(cmd) {
syscmd <- paste("vim --remote-send ",cmd," --servername ",vimserver,sep="")

The main point is that edtdbg sends remote commands to the Vim text editor. For instance, if we are running Vim with a server name – 168 and we want the cursor in Vim to move to line 12. Type this into a terminal (shell) window:

vim –remote-send 12G –server name 168

The effect would be the same as if you had typed.


Now, you must be aware of what does string manipulation refer to. In this tutorial of R string manipulation, we have studied about the use of string and their function with its uses. Along with string’s uses, it is also necessary to learn how to express these strings. We have also learned about regular expressions.

Now, it’s the turn of Data Manipulation in R

If you have any doubt regarding R string manipulation, ask in the comment section.

Your opinion matters
Please write your valuable feedback about DataFlair on Google

follow dataflair on YouTube

2 Responses

  1. Julián says:

    Thanks for sharing this information, it was very useful for me.
    A coment…:
    regexp() and gregexpr() aren’t clear, I mean that it is difficult to understand. Finally I don’t know what they are useful for.

    • DataFlair Team says:

      Hey Julian,

      Here is the solution to your problem:

      regular expressions are mainly used in searches and pattern finding. A regular expression (or regex for short) defines a pattern. the regexpr() and gregexpr() function use a regex and an input string to find parts of the string that match the pattern defined by the regex.

      I hope we have solved your query.

Leave a Reply

Your email address will not be published. Required fields are marked *