Version: Next

String

Strings can be written with double or single quotes, and the two differ in how they treat escapes.

A double-quoted string processes escape sequences: \" for a quote, \n for a newline, \t for a tab, \r for a carriage return.

puts("test\"string")   // test"string
puts("a\tb")           // a<tab>b

A single-quoted string is raw: nothing is escaped and a backslash is an ordinary character. This makes it convenient for text containing double quotes.

puts('test "string"')  // test "string"
puts('a\tb')           // a\tb, a literal backslash and t

Because a single-quoted string performs no escaping, it cannot contain a single quote at all -- 'test \'string' is a parse error. Use a double-quoted string when you need one.

a = "test_string";

b = "test" + "_string";

is_true = "test" == "test";
is_false = "test" == "string";

s = "abcdef"
puts(s[2])
puts(s[-2])
puts(s[:2])
puts(s[:-2])
puts(s[2:])
puts(s[-2:])
puts(s[1:-2])

s[2] = "C"
s[-2] = "E"
puts(s)

// should output
"c"
"e"
"ab"
"abcd"
"cdef"
"ef"
"bcd"
"abCdEf"

// you can also use single quotes
'test "string" with doublequotes'

// and you can scape a double quote in a double quote string
"te\"st" == 'te"st'

Literal Specific Methods

ascii()

Returns the character codes of the string, always as an array with one entry per character. A single-character string gives a one-element array and an empty string gives an empty array, so the result never has to be checked for its type before use.

"".ascii()
"a".ascii()
"abc".ascii()

Output
[]
[97]
[97, 98, 99]

capitalize()

Returns a copy with the first character upcased and every following character downcased, as Ruby's capitalize does. A capital in the middle of the string is therefore lost.

a = "hello World!"
a.capitalize()
a

Output
"hello World!"
"Hello world!"
"hello World!"

capitalize!()

Upcases the first character and downcases the rest in place, and returns the string, so calls can be chained.

a = "hello World!"
a.capitalize!()
a

Output
"hello World!"
"Hello world!"
"Hello world!"

chomp([STRING])

Returns a copy with one trailing line ending removed: \r\n, \n or \r. Given a string it removes one trailing occurrence of that string instead. Given "" it removes every trailing \n and \r\n, which is the way to drop blank lines at the end of a file.

a = "line\n"
a.chomp()
a.chomp() == "line"
"abcdd".chomp("d")
"a\n\n\n".chomp("")

Output
"line\n"
"line"
true
"abcd"
"a"

chomp!([STRING])

Removes one trailing line ending in place and returns the string, so calls can be chained. Takes the same optional separator as chomp.

a = "line\n"
a.chomp!()
a

Output
"line\n"
"line"
"line"

chop()

Returns a copy with the last character removed. A trailing \r\n is removed as a unit so a line ending is never left half there. Chopping an empty string gives an empty string rather than an error.

a = "abcd"
a.chop()
a
"".chop()

Output
"abcd"
"abc"
"abcd"
""

chop!()

Removes the last character in place and returns the string, so calls can be chained.

a = "abcd"
a.chop!()
a

Output
"abcd"
"abc"
"abc"

count(STRING)

Counts how often a given substring occurs in the string.

"test".count("t")

Output
2

downcase()

Returns a copy with all uppercase letters replaced by their lowercase counterparts.

a = "TEST"
a.downcase()
a

Output
"TEST"
"test"
"TEST"

downcase!()

Replaces uppercase characters with their lowercase counterparts in place and returns the string, so calls can be chained.

a = "TEST"
a.downcase!()
a

Output
"TEST"
"test"
"test"

empty?()

Returns true when the string has no characters.

"".empty?()
" ".empty?()

Output
true
false

end_with?(STRING...)

Returns true when the string ends with any of the given strings.

"test.rl".end_with?(".rl")
"test.rl".end_with?(".go")
"test.rl".end_with?(".go", ".rl")

Output
true
false
true

find(STRING)

Returns the character index of a given string if found. Otherwise returns -1

"test".find("e")

Output
1

format(ANY...)

Formats according to a format specifier and returns the resulting string

"%s is %d".format("a", 1)

Output
"a is 1"

include?(STRING)

Returns true when the string contains the given substring.

"test".include?("es")
"test".include?("xy")

Output
true
false

lines()

Splits the string at newline escape sequence and return all chunks in an array. Shorthand for string.split("\n").

"a\nb".lines()

Output
["a", "b"]

lstrip()

Returns a copy with leading whitespace removed. See rstrip for the trailing end and strip for both.

a = "  test  "
a.lstrip()
a

Output
"  test  "
"test  "
"  test  "

lstrip!()

Removes leading whitespace in place and returns the string, so calls can be chained.

a = "  test  "
a.lstrip!()
a

Output
"  test  "
"test  "
"test  "

replace(STRING, STRING)

Returns a copy with every occurrence of the first string replaced by the second. This is Ruby's gsub with plain strings rather than Ruby's replace.

a = "test"
a.replace("t", "f")
a

Output
"test"
"fesf"
"test"

replace!(STRING, STRING)

Replaces every occurrence of the first string with the second in place and returns the string, so calls can be chained.

a = "test"
a.replace!("t", "f")
a

Output
"test"
"fesf"
"fesf"

reverse()

Returns a copy of the string with all characters reversed.

a = "stressed"
a.reverse()
a

Output
"stressed"
"desserts"
"stressed"

reverse!()

Reverses the characters in place and returns the string, so calls can be chained.

a = "stressed"
a.reverse!()
a

Output
"stressed"
"desserts"
"desserts"

rstrip()

Returns a copy with trailing whitespace removed. See lstrip for the leading end and strip for both.

a = "  test  "
a.rstrip()
a

Output
"  test  "
"  test"
"  test  "

rstrip!()

Removes trailing whitespace in place and returns the string, so calls can be chained.

a = "  test  "
a.rstrip!()
a

Output
"  test  "
"  test"
"  test"

size()

Returns the amount of characters in the string.

"test".size()

Output
4

split([STRING])

Splits the string on a given seperator and returns all the chunks in an array. Default seperator is " "

"a b".split()
"a-b".split("-")

Output
["a", "b"]
["a", "b"]

start_with?(STRING...)

Returns true when the string starts with any of the given strings.

"test.rl".start_with?("test")
"test.rl".start_with?("prod")
"test.rl".start_with?("prod", "test")

Output
true
false
true

strip()

Returns a copy with leading and trailing whitespace removed.

a = "  test  "
a.strip()
a

Output
"  test  "
"test"
"  test  "

strip!()

Removes leading and trailing whitespace in place and returns the string, so calls can be chained.

a = "  test  "
a.strip!()
a

Output
"  test  "
"test"
"test"

swapcase()

Returns a copy with every uppercase character downcased and every lowercase character upcased.

a = "Hello World"
a.swapcase()
a

Output
"Hello World"
"hELLO wORLD"
"Hello World"

swapcase!()

Swaps the case of every character in place and returns the string, so calls can be chained.

a = "Hello World"
a.swapcase!()
a

Output
"Hello World"
"hELLO wORLD"
"hELLO wORLD"

upcase()

Returns a copy with all lowercase letters replaced by their uppercase counterparts.

a = "test"
a.upcase()
a

Output
"test"
"TEST"
"test"

upcase!()

Replaces lowercase characters with their uppercase counterparts in place and returns the string, so calls can be chained.

a = "test"
a.upcase!()
a

Output
"test"
"TEST"
"TEST"

Generic Literal Methods

is_a?(STRING)

Returns true when the value is of the given type or belongs to the given type group, so one question covers both. The name has to be one that exists: anything else is an error rather than a false, because a typo would otherwise read as a real answer. See Types and type groups.

nil.is_a?("NIL")
"a".is_a?("HASHABLE")
nil.is_a?("HASHABLE")
true.is_a?("INTEGERABLE")
"a".is_a?("INTEGER")

Output
true
true
false
true
false

methods()

Returns the names of the methods specific to this literal type, not including the generic methods listed on this page. The names are sorted, so the result is the same on every run. A type with no methods of its own returns an empty array.

1.0.methods().include?("round")
true.methods()

Output
true
[]

nil?()

Returns true only for nil. Reads better than comparing against nil at the end of a chain, and every type answers it.

nil.nil?()
1.nil?()
"".nil?()
[].first().nil?()

Output
true
false
false
true

to_f()

Converts an object to its float representation, or nil when it cannot. A nil result is what distinguishes a failed conversion from a genuine 0.0.

1.to_f()
"1.4".to_f()
"abc".to_f()
nil.to_f()

Output
1.0
1.4
nil
nil

to_i()

Converts an object to its integer representation, or nil when it cannot. A nil result is what distinguishes a failed conversion from a genuine 0. For strings a 0b, 0o or 0x prefix selects binary, octal or hexadecimal and is matched case insensitively, a leading zero followed only by octal digits is octal, and anything else is decimal. The resulting integer keeps the base it was parsed with, and integers of differing bases cannot be combined directly.

true.to_i()
false.to_i()
1234.to_i()
"4".to_i()
"0".to_i()
"0125".to_i()
"0x2322".to_i()
"0b1010".to_i()
"test".to_i()

Output
1
0
1234
4
0
0o125
0x2322
0b1010
nil

to_json()

Returns the object as json notation.

a = {"test": 1234}
a.to_json()

Output
{"test": 1234}
"{\"test\":1234}"

to_s()

Converts an object to its string representation, or the empty string when it has none. Takes no arguments; an integer renders in its own base, so use to_base first to change it.

true.to_s()
1234.to_s()
"test".to_s()
1.4.to_s()
nil.to_s()
"0b1010".to_i().to_s()

Output
"true"
"1234"
"test"
"1.4"
""
"0b1010"

type()

Returns the type of the object.

"test".type()

Output
"STRING"

type_groups()

Returns the type groups the value belongs to, sorted. ANY is not listed: every value belongs to it, so it would say nothing while prefixing every answer. It exists for signatures, where push(ANY) means the argument accepts anything, and is_a?("ANY") still answers true. See Types and type groups for what each group means.

1.type_groups()
nil.type_groups()
def() end.type_groups()
puts.type_groups()

Output
["COMPARABLE", "HASHABLE", "INTEGERABLE", "NUMERIC", "STRINGABLE"]
["STRINGABLE"]
["CALLABLE"]
["CALLABLE"]

wat()

Prints the type's literal-specific methods with their argument and return types, sorted by name, one per line. It returns nil rather than the listing: this exists to be read, and the REPL echoes a returned value through its escaped representation, which would put the whole thing on one line. Use methods when the names are wanted as data. A type with no methods of its own prints only the heading.

true.wat()
1.0.wat()

Output
BOOLEAN supports the following methods:
nil
FLOAT supports the following methods:
abs()
ceil([INTEGER])
divmod(FLOAT)
finite?()
floor([INTEGER])
infinite?()
nan?()
negative?()
positive?()
round([INTEGER])
truncate([INTEGER])
zero?()
nil

Literal Specific Methods​

ascii()​

capitalize()​

capitalize!()​

chomp([STRING])​

chomp!([STRING])​

chop()​

chop!()​

count(STRING)​

downcase()​

downcase!()​

empty?()​

end_with?(STRING...)​

find(STRING)​

format(ANY...)​

include?(STRING)​

lines()​

lstrip()​

lstrip!()​

replace(STRING, STRING)​

replace!(STRING, STRING)​

reverse()​

reverse!()​

rstrip()​

rstrip!()​

size()​

split([STRING])​

start_with?(STRING...)​

strip()​

strip!()​

swapcase()​

swapcase!()​

upcase()​

upcase!()​

Generic Literal Methods​

is_a?(STRING)​

methods()​

nil?()​

to_f()​

to_i()​

to_json()​

to_s()​

type()​

type_groups()​

wat()​