Ruby Strings (String)

The String object in Ruby 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 (""), the difference being that double-quoted strings can support more escape characters.

Single-quoted strings

The simplest string is a single-quoted string, which is a string placed within single quotes:

'This is a Ruby program's string'

If you need to use a single quote character within a single-quoted string, you need to use a backslash (\) in the single-quoted string so that the Ruby interpreter will not consider this single quote character as the end of the string:

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

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

The following are the features of strings in Ruby.

Double-quoted strings

We can use in double-quoted strings: #{} Hash and curly braces to calculate the value of an expression:

Embedding variables in a string:

Online example

#!/usr/bin/ruby
#　-*-　coding: UTF-8　-*-
　
name1　= "Joe"
name2　= "Mary"
puts "Hello #{name1}, #{name2}} where?

The output of the above example is as follows:

Hello Joe, where is Mary?

Mathematical operations in a string:

Online example

#!/usr/bin/ruby
#　-*-　coding: UTF-8　-*-
　
x, y, z =　12,　36,　72
puts "The value of x is #{x"
puts "x　+　The value of y is #{x　+　y"
puts "x　+　y　+　The average of z is #{(x　+　y　+　z)/3　"}

The output of the above example is as follows:

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

Ruby also supports a string variable that is guided by %q and %Q. %q uses single quote quoting rules, while %Q uses double quote quoting rules, followed by a starting delimiter such as (! [ { and an ending delimiter such as } ] ) etc.

The characters following q or Q are delimiters. Delimiters can be any non-alphanumeric single-byte character. For example: [,{,(,<,!, etc., the string will continue to be read until a matching end delimiter is found.

Online 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 as follows:

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

Escape characters

The index lists the escape characters or non-printable characters that can be escaped with the backslash symbol.

Note:Escape characters are parsed within a string enclosed in double quotes. Escape characters are not parsed and are output as is within a string enclosed in single quotes.

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, where characters may be represented by one to four bytes.

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

$KCODE = 'u'

Below are the possible values of $KCODE.

Built-in string methods

We need an example of a String object to call the String method. Here are some ways to create a String object:

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

This will return a string containing str A new string object for the copy. Now, using str Object, we can call any available example method. For example:

Online example

#!/usr/bin/ruby
　
myStr　=　String.new("THIS　IS　TEST")
foo　=　myStr.downcase
　
puts　"#{foo}"

This will produce the following result:

this　is　test

The following are public string methods (assuming str is a String object):

String unpack command

The following table lists the unpack commands of the String#unpack method.

Online example

Try the following examples to unpack various data.

"abc \0\0abc \0\0".unpack('A'6Z6#=> ['abc', 'abc ']
"abc \0\0".unpack('a'3a3#=> ['abc', '  \000\000']
"abc \0abc \0".unpack('Z')*Z*
"aa".unpack('b')8B810000110", "01100001"]
"aaa".unpack('h')2H2c') => ['"']16", "61"　97]
"\xfe\xff\xfe\xff".unpack('sS') => [-2,　65534]
"now="20is".unpack('M')*
"whole".unpack('xax') => ['now is']2aX2aX1aX2a') => ['h', 'e', 'l', 'l', 'o']