Ruby String

In Ruby, the String object is used to store or manipulate a sequence of one or more bytes.

Ruby strings are divided into single-quoted strings (') and double-quoted strings ("), with the difference being that double-quoted strings support more escape characters.

Single-Quoted Strings

The simplest form of a string is a single-quoted string, which is a string stored within single quotes:

'This is a string in a Ruby program'

If you need to use a single quote within a single-quoted string, you need to escape it with a backslash (), so that the Ruby interpreter does not consider this single quote as the end of the string:

'Won\'t you read O\'Reilly\'s book?'

The backslash can also escape another backslash, so that the second backslash itself is not interpreted as an escape character.

Here are some features related to strings in Ruby.

Double-Quoted Strings

In double-quoted strings, we can use #{} with the hash sign and curly braces to evaluate the value of an expression:

Embedding variables in a string:

Example

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

name1 = "Joe"
name2 = "Mary"
puts "Hello #{name1}, where is #{name2}?"

The output of the above example is:

Hello Joe, where is Mary?

Performing mathematical operations within a string:

Example

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

x, y, z = 12, 36, 72
puts "The value of x is #{x}"
puts "The value of x + y is #{x + y}"
puts "The average of x + y + z is #{(x + y + z)/3}"

The output of the above example is:

The value of x is 12
The value of x + y is 48
The average of x + y + z is 40

Ruby also supports string variables initiated with %q and %Q, where %q uses single-quote rules and %Q uses double-quote rules, followed by a start delimiter such as (! [ { etc. and a matching end delimiter such as } ] ).

The character following q or Q is the delimiter. The delimiter can be any non-alphanumeric single-byte character such as: [, {, (, <, !, etc. The string will be read until a matching end delimiter is found.

Example

#!/usr/bin/ruby
# -*- coding: UTF-8 -*-

desc1 = %Q{Ruby strings can use '' and ""}
desc2 = %q|Ruby strings can use '' and ""|

puts desc1
puts desc2

The output of the above example is:

Ruby strings can use '' and ""
Ruby strings can use '' and ""

Escape Characters

The table below lists the escape characters that can be used with a backslash symbol for escaping or non-printable characters.

Note: Within a string enclosed in double quotes, escape characters are parsed. Within a string enclosed in single quotes, escape characters are not parsed and are output as is.

Character Encoding

Ruby's default character set is ASCII, where characters can be represented by a single byte. If you use UTF-8 or other modern character sets, characters may be represented by one to four bytes.

You can change the character set at the beginning of the program using $KCODE, as shown below:

$KCODE = 'u'

Here are the possible values for $KCODE.

Built-in String Methods

We need an instance of a String object to call String methods. Here is how to create an instance of a String object:

new [String.new(str="")]

This will return a new string object containing a copy of str. Now, using the str object, we can call any available instance methods. For example:

Example

#!/usr/bin/ruby

myStr = String.new("THIS IS TEST")
foo = myStr.downcase

puts "#{foo}"

This will produce the following result:

this is test

Below are some public string methods (assuming str is a String object):

String unpack Directives

The table below lists the unpack directives for the String#unpack method.

Examples

Try the following examples to unpack various data.

"abc \0\0abc \0\0".unpack('A6Z6')   #=> ["abc", "abc "]
"abc \0\0".unpack('a3a3')           #=> ["abc", " \000\000"]
"abc \0abc \0".unpack('Z*Z*')       #=> ["abc ", "abc "]
"aa".unpack('b8B8')                 #=> ["10000110", "01100001"]
"aaa".unpack('h2H2c')               #=> ["16", "61", 97]
"\xfe\xff\xfe\xff".unpack('sS')     #=> [-2, 65534]
"now=20is".unpack('M*')             #=> ["now is"]
"whole".unpack('xax2aX2aX1aX2a')    #=> ["h", "e", "l", "l", "o"]