Returns a substring of self, or nil if the substring cannot be constructed.
With integer arguments index and length given, returns the substring beginning at the given index of the given length (if possible), or nil if length is negative or index falls outside of self:
s = '0123456789' # => "0123456789" s.byteslice(2) # => "2" s.byteslice(200) # => nil s.byteslice(4, 3) # => "456" s.byteslice(4, 30) # => "456789" s.byteslice(4, -1) # => nil s.byteslice(40, 2) # => nil
In either case above, counts backwards from the end of self if index is negative:
s = '0123456789' # => "0123456789" s.byteslice(-4) # => "6" s.byteslice(-4, 3) # => "678"
With Range argument range given, returns byteslice(range.begin, range.size):
s = '0123456789' # => "0123456789" s.byteslice(4..6) # => "456" s.byteslice(-6..-4) # => "456" s.byteslice(5..2) # => "" # range.size is zero. s.byteslice(40..42) # => nil
In all cases, a returned string has the same encoding as self:
s.encoding # => #<Encoding:UTF-8> s.byteslice(4).encoding # => #<Encoding:UTF-8>
Replaces some or all of the content of self with str, and returns self. The portion of the string affected is determined using the same criteria as String#byteslice, except that length cannot be omitted. If the replacement string is not the same length as the text it is replacing, the string will be adjusted accordingly.
If str_index and str_length, or str_range are given, the content of self is replaced by str.byteslice(str_index, str_length) or str.byteslice(str_range); however the substring of str is not allocated as a new string.
The form that take an Integer will raise an IndexError if the value is out of range; the Range form will raise a RangeError. If the beginning or ending offset does not land on character (codepoint) boundary, an IndexError will be raised.
Returns a copy of self with each invalid byte sequence replaced by the given replacement_string.
With no block given and no argument, replaces each invalid sequence with the default replacement string ("�" for a Unicode encoding, '?' otherwise):
s = "foo\x81\x81bar" s.scrub # => "foo��bar"
With no block given and argument replacement_string given, replaces each invalid sequence with that string:
"foo\x81\x81bar".scrub('xyzzy') # => "fooxyzzyxyzzybar"
With a block given, replaces each invalid sequence with the value of the block:
"foo\x81\x81bar".scrub {|bytes| p bytes; 'XYZZY' } # => "fooXYZZYXYZZYbar"
Output:
"\x81" "\x81"
Like String#scrub, except that any replacements are made in self.
Returns self if self is not frozen and can be mutated without warning issuance.
Otherwise returns self.dup, which is not frozen.
Returns a frozen, possibly pre-existing copy of the string.
The returned String will be deduplicated as long as it does not have any instance variables set on it and is not a String subclass.
Note that -string variant is more convenient for defining constants:
FILENAME = -'config/database.yml'
while dedup is better suitable for using the method in chains of calculations:
@url_list.concat(urls.map(&:dedup))
Returns a printable version of self, enclosed in double-quotes, with special characters escaped, and with non-printing characters replaced by hexadecimal notation:
"hello \n ''".dump # => "\"hello \\n ''\"" "\f\x00\xff\\\"".dump # => "\"\\f\\x00\\xFF\\\\\\\"\""
Related: String#undump (inverse of String#dump).
Returns an unescaped version of self:
s_orig = "\f\x00\xff\\\"" # => "\f\u0000\xFF\\\"" s_dumped = s_orig.dump # => "\"\\f\\x00\\xFF\\\\\\\"\"" s_undumped = s_dumped.undump # => "\f\u0000\xFF\\\"" s_undumped == s_orig # => true
Related: String#dump (inverse of String#undump).
Returns a string containing the upcased characters in self:
s = 'Hello World!' # => "Hello World!" s.upcase # => "HELLO WORLD!"
The casing may be affected by the given options; see Case Mapping.
Related: String#upcase!, String#downcase, String#downcase!.
Returns a string containing the downcased characters in self:
s = 'Hello World!' # => "Hello World!" s.downcase # => "hello world!"
The casing may be affected by the given options; see Case Mapping.
Related: String#downcase!, String#upcase, String#upcase!.
Returns a string containing the characters in self; the first character is upcased; the remaining characters are downcased:
s = 'hello World!' # => "hello World!" s.capitalize # => "Hello world!"
The casing may be affected by the given options; see Case Mapping.
Related: String#capitalize!.
Returns a string containing the characters in self, with cases reversed; each uppercase character is downcased; each lowercase character is upcased:
s = 'Hello World!' # => "Hello World!" s.swapcase # => "hELLO wORLD!"
The casing may be affected by the given options; see Case Mapping.
Related: String#swapcase!.
Upcases the characters in self; returns self if any changes were made, nil otherwise:
s = 'Hello World!' # => "Hello World!" s.upcase! # => "HELLO WORLD!" s # => "HELLO WORLD!" s.upcase! # => nil
The casing may be affected by the given options; see Case Mapping.
Related: String#upcase, String#downcase, String#downcase!.
Downcases the characters in self; returns self if any changes were made, nil otherwise:
s = 'Hello World!' # => "Hello World!" s.downcase! # => "hello world!" s # => "hello world!" s.downcase! # => nil
The casing may be affected by the given options; see Case Mapping.
Related: String#downcase, String#upcase, String#upcase!.
Upcases the first character in self; downcases the remaining characters; returns self if any changes were made, nil otherwise:
s = 'hello World!' # => "hello World!" s.capitalize! # => "Hello world!" s # => "Hello world!" s.capitalize! # => nil
The casing may be affected by the given options; see Case Mapping.
Related: String#capitalize.
Upcases each lowercase character in self; downcases uppercase character; returns self if any changes were made, nil otherwise:
s = 'Hello World!' # => "Hello World!" s.swapcase! # => "hELLO wORLD!" s # => "hELLO wORLD!" ''.swapcase! # => nil
The casing may be affected by the given options; see Case Mapping.
Related: String#swapcase.
Interprets the leading substring of self as a string of hexadecimal digits (with an optional sign and an optional 0x) and returns the corresponding number; returns zero if there is no such leading substring:
'0x0a'.hex # => 10 '-1234'.hex # => -4660 '0'.hex # => 0 'non-numeric'.hex # => 0
Related: String#oct.
Interprets the leading substring of self as a string of octal digits (with an optional sign) and returns the corresponding number; returns zero if there is no such leading substring:
'123'.oct # => 83 '-377'.oct # => -255 '0377non-numeric'.oct # => 255 'non-numeric'.oct # => 0
If self starts with 0, radix indicators are honored; see Kernel#Integer.
Related: String#hex.
Returns an array of substrings of self that are the result of splitting self at each occurrence of the given field separator field_sep.
When field_sep is $;:
If $; is nil (its default value), the split occurs just as if field_sep were given as a space character (see below).
If $; is a string, the split occurs just as if field_sep were given as that string (see below).
When field_sep is ' ' and limit is 0 (its default value), the split occurs at each sequence of whitespace:
'abc def ghi'.split(' ') => ["abc", "def", "ghi"] "abc \n\tdef\t\n ghi".split(' ') # => ["abc", "def", "ghi"] 'abc def ghi'.split(' ') => ["abc", "def", "ghi"] ''.split(' ') => []
When field_sep is a string different from ' ' and limit is 0, the split occurs at each occurrence of field_sep; trailing empty substrings are not returned:
'abracadabra'.split('ab') => ["", "racad", "ra"] 'aaabcdaaa'.split('a') => ["", "", "", "bcd"] ''.split('a') => [] '3.14159'.split('1') => ["3.", "4", "59"] '!@#$%^$&*($)_+'.split('$') # => ["!@#", "%^", "&*(", ")_+"] 'тест'.split('т') => ["", "ес"] 'こんにちは'.split('に') => ["こん", "ちは"]
When field_sep is a Regexp and limit is 0, the split occurs at each occurrence of a match; trailing empty substrings are not returned:
'abracadabra'.split(/ab/) # => ["", "racad", "ra"] 'aaabcdaaa'.split(/a/) => ["", "", "", "bcd"] 'aaabcdaaa'.split(//) => ["a", "a", "a", "b", "c", "d", "a", "a", "a"] '1 + 1 == 2'.split(/\W+/) # => ["1", "1", "2"]
If the Regexp contains groups, their matches are also included in the returned array:
'1:2:3'.split(/(:)()()/, 2) # => ["1", ":", "", "", "2:3"]
As seen above, if limit is 0, trailing empty substrings are not returned:
'aaabcdaaa'.split('a') => ["", "", "", "bcd"]
If limit is positive integer n, no more than n - 1- splits occur, so that at most n substrings are returned, and trailing empty substrings are included:
'aaabcdaaa'.split('a', 1) # => ["aaabcdaaa"] 'aaabcdaaa'.split('a', 2) # => ["", "aabcdaaa"] 'aaabcdaaa'.split('a', 5) # => ["", "", "", "bcd", "aa"] 'aaabcdaaa'.split('a', 7) # => ["", "", "", "bcd", "", "", ""] 'aaabcdaaa'.split('a', 8) # => ["", "", "", "bcd", "", "", ""]
Note that if field_sep is a Regexp containing groups, their matches are in the returned array, but do not count toward the limit.
If limit is negative, it behaves the same as if limit was zero, meaning that there is no limit, and trailing empty substrings are included:
'aaabcdaaa'.split('a', -1) # => ["", "", "", "bcd", "", "", ""]
If a block is given, it is called with each substring:
'abc def ghi'.split(' ') {|substring| p substring }
Output:
"abc" "def" "ghi"
Related: String#partition, String#rpartition.
Returns an array of the bytes in self:
'hello'.bytes # => [104, 101, 108, 108, 111] 'тест'.bytes # => [209, 130, 208, 181, 209, 129, 209, 130] 'こんにちは'.bytes # => [227, 129, 147, 227, 130, 147, 227, 129, 171, 227, 129, 161, 227, 129, 175]
Returns an array of the characters in self:
'hello'.chars # => ["h", "e", "l", "l", "o"] 'тест'.chars # => ["т", "е", "с", "т"] 'こんにちは'.chars # => ["こ", "ん", "に", "ち", "は"]
Returns a new string with the characters from self in reverse order.
'stressed'.reverse # => "desserts"
Returns self with its characters reversed:
s = 'stressed' s.reverse! # => "desserts" s # => "desserts"
Concatenates each object in objects to self and returns self:
s = 'foo' s.concat('bar', 'baz') # => "foobarbaz" s # => "foobarbaz"
For each given object object that is an Integer, the value is considered a codepoint and converted to a character before concatenation:
s = 'foo' s.concat(32, 'bar', 32, 'baz') # => "foo bar baz"
Related: String#<<, which takes a single argument.
Concatenates object to self and returns self:
s = 'foo' s << 'bar' # => "foobar" s # => "foobar"
If object is an Integer, the value is considered a codepoint and converted to a character before concatenation:
s = 'foo' s << 33 # => "foo!"
If that codepoint is not representable in the encoding of string, RangeError is raised.
s = 'foo' s.encoding # => <Encoding:UTF-8> s << 0x00110000 # 1114112 out of char range (RangeError) s = 'foo'.encode(Encoding::EUC_JP) s << 0x00800080 # invalid codepoint 0x800080 in EUC-JP (RangeError)
If the encoding is US-ASCII and the codepoint is 0..0xff, string is automatically promoted to ASCII-8BIT.
s = 'foo'.encode(Encoding::US_ASCII) s << 0xff s.encoding # => #<Encoding:BINARY (ASCII-8BIT)>
Related: String#concat, which takes multiple arguments.