core : string

String literals live between single or double quotes.
*   +   <<   <=>   ==   alpha?   alphanum?   blank?   chomp   chomp!   dice   downcase   downcase!   each   empty?   find   get   include?   length   match   new   numeric?   reverse   reverse!   reverse_each   set   split   string?   strip   strip!   sub   sub!   to_byte   to_f   to_i   to_s   upcase   upcase!  

(string) *

string * num

Create a new string with num copies of the original string.

(string) +

string1 + string2

Concatenates the two strings and creates a new string.

(self) «

string « str

Concatenate a second string onto the current string. Modifies and returns the current string.

 a = "a"
 a << "b"
 a == "ab"

(number) <=>

lhs <=> rhs

Compares two strings. Returns 1 if lhs is greater, -1 if rhs is greater, and 0 if the two are equal.

(boolean) ==

string1 == string2

Compare the contents of two strings.

(boolean) alpha?


Returns true if the string contains only letters.

 "abC".alpha?     # Returns true
 "X1z".alpha?     # Returns false

(boolean) alphanum?


Returns true if the string contains only letters and numbers.

 "br47".alphanum?      # Returns true
 "bl_nk".alphanum?     # Returns false

(boolean) blank?


Returns true if the string is empty or only contains whitespace characters.

 "".blank?      # Returns true
 "\n".blank?    # Returns true

(string) chomp


Create a new string with any line endings removed.

 "a\n\n".chomp  # Returns "a"

(string) chomp!


Remove any line endings from string.

 a = "a\r\n"
 a              # Returns "a"

(array) dice


Splits string into an array with each character as as single element.

 "abc".dice == ["a" "b" "c"]

(string) downcase


Create a new string with all letters downcased.

(self) downcase!


Downcase all letters in the string,

(string) each

string.each block

Interate over each character in the string, passing them into the given block.

 a = []
 "abc".each { letter |
   a << letter

 a             # Returns ["a", "b", "c"]

(boolean) empty?


Returns true if the string is empty (zero length), false otherwise.

 "".empty?      # Returns true
 "a".empty?     # Returns false
 "\n".empty?    # Returns false

(number) find

string.find substring

Returns the index of the given substring inside the original string. If no match is found, returns null.

(string) get

string.get index
string.get start, end

Retrieves a section of the string. If a single index is used, returns at most one character. For indexes out of range, returns an empty string. Negative indexes can be used to start from the end of the string. While this method can be called literally, it is more common to use the square bracket ([]) form.

 "abc"[0]      # Returns "a"
 "abc"[0, 1]   # Returns "ab"
 "abc"[-1]     # Returns "c"
 "abc"[-1, -2] # Returns "bc"
 "abc"[-1 ,1]  # Returns "bc"

(boolean) include?

string.include? substring
string.include? regex

Returns true if the string includes the given substring or regular expression.

(number) length


Returns the length of the string.

(object) match

string.match regex
string.match regex, index

Returns: object or false This method can be used to find substrings inside a string matching the given regular expression. An optional start index can be provided. If a match is found, an match object is

(string) new

Create a new string. There should be no reason to use this directly.

(boolean) numeric?


Returns true if the string only includes decimal digits and an optional leading minus sign.

 "five".numeric?      # Returns false
 "-127".numeric?      # Returns true

(string) reverse


Copy and reverse string.

(self) reverse!


Reverse string.

(boolean) reverse_each

string.reverse_each block

Iterates over each character in string, starting from the end.

 a = []
 "abc".each { letter |
   a << letter

 a             # Returns ["c", "b", "a"]

(self) set

string.set index, character

Sets the given index in the string to the given character.

(array) split

string.split separator

Splits the string into an array based on the given separator, which should be a string. If no separator is given, “ “ is assumed.

 a = "hello, there"
 a.split       #["hello,", "there"]
 a.split ", "  #["hello", "there"]
 a.split "z"   #["hello, there"]

(boolean) string?


Returns true…because it is a string.

(string) strip


Returns a new string with all whitespace removed from the beginning and end of the string.

 "  a\n".strip       # Returns "a"

(self) strip!


Removes all whitespace from the beginning and end of the string.

 a = "   a\n"
 a                  # Returns "a"

(string) sub

string.sub regex, replacement
string.sub regex, replacement, limit

Returns a new string with instances of the given pattern replaced by the provided replacement string. Instead of a string, the replacement argument can be a function which will be called with each match. The string returned by the function will be used as the replacement. A limit can be used to limit how many replacements are made.

(string) sub

string.sub regex, replacement

Same as using string.sub with a limit of 1.

(self) sub!

string.sub! regex, replacement

Same as using string.sub! with a limit of 1.

(self) sub!

string.sub! regex, replacement
string.sub! regex, replacement, limit

Same as string.sub, but modifies the original string.

(object) to_byte


Returns: number or array If string is a single character, returns the decimal value associated with that character. If the string is longer than a single character, returns an array of values.

 "a".to_byte   # 97
 "abc".to_byte # [97, 98, 99]

(number) to_f


Interprets the given string as an number.

(number) to_i

string.to_i base

Interprets the given string as an integer. By default the string is expected to be decimal representation.

(self) to_s


Does nothing, just returns the string itself.

(string) upcase


Return a new string with all letters changed to uppercase.

(self) upcase!


Convert all letters in string to uppercase.

Fork me on GitHub