| |
# comment Single line comment a = 10
b = 20
tambah = a + b
puts tambah a = 10
b = 20
tambah = a + b
puts tambah a = "hello"
b = "world"
c = "!"
d = a + b + c
puts d a = "hello"
b = "world"
c = "!"
d = a + b + c
puts d
| comment# Ruby treats nil as a false value in conditions,
# you could write the following to process the lines in a file.
1111 11a =10
b =20
c = a + b
puts c
|
| |
| |
Assignment – An assignment statement sets the variable or attribute on its left side (the lvalue) to refer to the value on the right (the rvalue). It then returns that value as the result of the assignment expression. This means you can chain assignments, and you can perform assignments in some unexpected places.
– In older Ruby versions, the result of the assignment was the value returned by the attribute-setting method. In Ruby 1.8, the value of the assignment is always the value of the parameter; the return value of the method is discarded.
– Ruby assignments are effectively performed in parallel, so the values assigned are not affected by the assignment itself. The values on the right side are evaluated in the order in which they appear before any assignment is made to variables or attributes on the left.
– When an assignment has more than one lvalue, the assignment expression returns an array of the rvalues. If an assignment contains more lvalues than rvalues, the excess lvalues are set to nil. If a multiple assignment contains more rvalues than lvalues, the extra rvalues are ignored. If an assignment has just one lvalue and multiple rvalues, the rvalues are converted to an array and assigned to the lvalue.
– In common with many other languages, Ruby has a syntactic shortcut: a = a + 2 may be written as a += 2.
– Something you won’t find in Ruby are the autoincrement (++) and autodecrement (--) operators of C and Java. Use the += and -= forms instead.
| return value of the method is discardedclass Test
def val=(val) #creates only writable member of class
@val = val
return 99
end
end
t = Test.new
a = t.val = 2
a #-->2
|
Returning Anything that can reasonably return a value does.
The if and case statements both return the value of the last expression executed
| returninga = b = c = 0 #--> 0
a = b = 1 + 2 + 3
a #-->6
b #-->6
a = (b = 1 + 2) + 3
a #-->6
b #-->3
File.open(name = gets.chomp)
[ 3, 1, 7, 0 ].sort.reverse #-->[7, 3, 1, 0]
if returnssong_type =
if song.mp3_type == MP3::Jazz
if song.written < Date.new(1935, 1, 1)
Song::TradJazz
else
Song::Jazz
end
else
Song::Other
end
if returns in next lineswer =
if (false)
1
else
2
end
puts wer #-> 2
case returnsrating =
case votes_cast
when 0...10 then Rating::SkipThisOne
when 10...50 then Rating::CouldDoBetter
else Rating::Rave
end
multiple, multy multi return # Really a return of an array.def multy
return 1, 2, 3
end
w1, w2, w3 = multy # assigns each element of the array returned to the variables (See parallel assignment, below)
puts w1 #--> 1
puts w2 #--> 2
puts w3 #--> 3
conditions returnspart = [0, 1]
puts val = part && part[1] || '1' #-> 1
puts val = part && part[2] || '2' #-> 2
|
Parallel assignment An assignment expression may have one or more lvalues and one or more rvalues. This section explains how Ruby handles assignment with different combinations of arguments.
1. If the last rvalue is prefixed with an asterisk and is an object of class Array, the rvalue is replaced with the elements of the array, with each element forming its own rvalue.
2. If the assignment contains multiple lvalues and one rvalue, the rvalue is converted into an Array, and this array is expanded into a set of rvalues as described in (1).
3. Successive rvalues are assigned to the lvalues. This assignment effectively happens in parallel, so that (for example) a,b=b,a swaps the values in "a" and "b."
4. If there are more lvalues than rvalues, the excess will have nil assigned to them.
5. If there are more rvalues that lvalues, the excess will be ignored.
6. These rules are modified slightly if the last lvalue is preceded with an asterisk. This lvalue will always receive an array during the assignment. The array will consist of whatever rvalue would normally have been assigned to this lvalue, followed by the excess rvalues (if any).
7. If an lvalue is a parenthesized list, it is treated as a nested assignment statement, and the list is assigned from the corresponding rvalue as described by these rules. Collapse and expand arrays using parallel assignment You can collapse and expand arrays using Ruby’s parallel assignment operator.
If the last lvalue is preceded by an asterisk, all the remaining rvalues will be collected and assigned to that lvalue as an array.
Similarly, if the last rvalue is an array, you can prefix it with an asterisk, which effectively expands it into its constituent values in place. (This is not necessary if the rvalue is the only thing on the right side—the array will be expanded automatically.)
| * parallel assignmenta, b = b, a #swap the values in two variables
x = 0 #-> 0
a, b, c = x, (x += 1), (x += 1) #-> [0, 1, 2]
a, b, c = 1, "cat", [ 3, 4, 5 ]
a = [1, 2, 3, 4]
b, c = a #-> b == 1, c == 2
b, *c = a #-> b == 1, c == [2, 3, 4]
b, c = 99, a #-> b == 99, c == [1, 2, 3, 4]
b, *c = 99, a #-> b == 99, c == [[1, 2, 3, 4]]
b, c = 99, *a #-> b == 99, c == 1
b, *c = 99, *a #-> b == 99, c == [1, 2, 3, 4]
|
Nested assignments Parallel assignments have one more feature worth mentioning. The left-hand side of an assignment may contain a parenthesized list of terms. Ruby treats these terms as if they were a nested assignment statement. It extracts out the corresponding rvalue, assigning it to the parenthesized terms, before continuing with the higher-level assignment.
| * nested assignmentsb, (c, d), e = 1,2,3,4 #-> b == 1, c == 2, d == nil, e == 3
b, (c, d), e = [1,2,3,4] #-> b == 1, c == 2, d == nil, e == 3
b, (c, d), e = 1,[2,3],4 #-> b == 1, c == 2, d == 3, e == 4
b, (c, d), e = 1,[2,3,4],5 #-> b == 1, c == 2, d == 3, e == 5
b, (c,*d), e = 1,[2,3,4],5 #-> b == 1, c == 2, d == [3, 4], e == 5
|
compare Comparison == Test for equal value.
=== Used to compare the each of the items with the target in the when clause of a case statement.
<=> General comparison operator. Returns -1, 0, or +1, depending on whether its receiver is less than, equal to, or greater than its argument.
<, <=, >=, > Comparison operators for less than, less than or equal, greater than or equal, and greater than.
=~ Regular expression pattern match.
eql? True if the receiver and argument have both the same type and equal values. 1 == 1.0 returns true, but 1.eql?(1.0) is false.
equal? True if the receiver and argument have the same object ID.
– Both == and =~ have negated forms, != and !~. However, these are converted by Ruby when your program is read. a != b is equivalent to !(a == b), and a !~ b is the same as !(a =~ b). This means that if you write a class that overrides == or =~ you get a working != and !~ for free. But on the flip side, this also means that you cannot define != and !~ independent of == and =~, respectively.
– You can use a Ruby range as a boolean expression. A range such as exp1..exp2 will evaluate as false until exp1 becomes true. The range will then evaluate as true until exp2 becomes true. Once this happens, the range resets, ready to fire again. We show some examples of this on page equality obj == otherObj → true or false At the Object level, == returns true only if obj and other are the same object. Typically, this method is overridden in descendent classes to provide class-specific meaning. .equal? obj.equal?(otherObj) → true or false Unlike ==, the equal? method should never be overridden by subclasses: it is used to determine object identity (that is, a.equal?(b) if a is the same object as b). .eql? obj.eql?(otherObj) → true or false The eql? method returns true if obj and otherObj have the same value. Used by Hash to test members for equality. For objects of class Object, eql? is synonymous with ==. Subclasses normally continue this tradition, but there are exceptions. Numeric types, for example, perform type conversion across ==, but not across eql?, so:
1 == 1.0 #-> true
1.eql? 1.0 #-> false
| |
document here, here document, HereDoc Here document A here document consists of lines in the source up to, but not including, the terminating string that you specify after the << characters. Normally, this terminator must start in the first column. However, if you put a minus sign after the << characters (<<-), you can indent the terminator.
Strings can continue across multiple input lines, in which case they will contain newline characters. It is also possible to use here documents to express long string literals. Whenever Ruby parses the sequence <<identifier or <<quoted string, it replaces it with a string literal built from successive logical input lines. It stops building the string when it finds a line that starts with the identifier or the quoted string. You can put a minus sign immediately after the << characters, in which case the terminator can be indented from the left margin. If a quoted string was used to specify the terminator, its quoting rules will be applied to the here document; otherwise, double-quoting rules apply.
| here documentaString = <<END_OF_STRING
The body of the string
is the input lines up to
one ending with the same
text that followed the '<<'
END_OF_STRING
indent the terminatorprint <<-STRING1, <<-STRING2
Concat
STRING1
enate
STRING2
produces: Concat
enate
quoting rulesa = 123
print <<HERE
Double quoted \
here document.
Sum = #{a + 1}
HERE
print <<-'THERE'
This is single quoted.
The above used #{a + 1}
THERE
produces: Double quoted here document.
Sum = 124
This is single quoted.
The above used #{a + 1}
|
null nil Object, just like any other, that happens to represent nothing. spaceship <=> Compares two values, returning -1, 0, or +1 depending on whether the first is less than, equal to, or greater than the second.
| |
$_ variable Global variable $_
| This uses some behind-the-scenes magic behavior: gets assigns the last line read to the global variable $_, the ~ operator does a regular expression match against $_, and print with no arguments prints $_.file = File.open("ordinal")
while file.gets
print if ~/third/ .. ~/fifth/
end
|
| |
BEGIN and END Blocks Every Ruby source file can declare blocks of code to be run as the file is being loaded (the BEGIN blocks) and after the program has finished executing (the END blocks).
– A program may include multiple BEGIN and END blocks. BEGIN blocks are executed in the order they are encountered. END blocks are executed in reverse order.
| BEGIN & END blocksBEGIN {puts "begin code 1"}
END {puts "end code 1"}
puts "line 2"
BEGIN {puts "begin code 2"}
END {puts "end code 2"}
puts "line 3"
produces:
begin code 1
begin code 2
line 1
line 2
line 3
end code 2
end code 1
|
%{} General Delimited Input There are alternative forms of literal strings, arrays, regular expressions, and shell commands that are specified using a generalized delimited syntax.
– All these literals start with a percent character, followed by a single character that identifies the literal's type.
– Following the type character is a delimiter, which can be any character.
– If the delimiter is one of the characters "(", "[", "{", or "<", the literal consists of the characters up to the matching closing delimiter, taking account of nested delimiter pairs. For all other delimiters, the literal comprises the characters up to the next occurrence of the delimiter character.
– Delimited strings may continue over multiple lines.
%q – Single-quoted string
%Q, % – Double-quoted string
%w – Array of tokens
%W – Array of tokens with substitutions
%r – Regular expression pattern
%x – Shell command
| usagevar = 'Exp'
%q/this is a string #{var}/ #-> this is a string #{var}
%Q-string #{var}- #-> string Exp
%(a (nested) string var=#{var}) #-> a (nested) string var=Exp
(%w<q va\ r e r t y>)[1] #-> va r
['q', var, 'e', 'r', 't', 'y'][1] #-> Exp
puts %q{def fred(a)
a.each { |i| puts i }
end}
produces:
def fred(a)
a.each { |i| puts i }
end
%w %W samplesvalue = 1
a = %w{ #{value} } # => ["\#{value}"]
b = %W{ #{value} } # => ["1"]
|
: Symbols A Ruby symbol is the internal representation of a name. You construct the symbol for a name by preceding the name with a colon.
– A particular name will always generate the same symbol, regardless of how that name is used within the program.
– Other languages call this process "interning" and call symbols "atoms".
| symbols:Object
:myVariable
|
| |
about The class Array holds a collection of object references. Each object reference occupies a position in the array, identified by a non-negative integer index.
It’s more efficient to access array elements, but hashes provide more flexibility
– Literals of class Array are created by placing a comma-separated series of object references between square brackets.
– A trailing comma is ignored.
– Arrays of strings can be constructed using a shortcut notation, %w, which extracts space-separated tokens into successive elements of the array. A space can be escaped with a backslash. This is a form of general delimited input. .., ..., two periods Indexing elements – Ruby array index starts at zero.
– Index an array with a non-negative integer, and it returns the object at that position or returns nil if nothing is there.
– Index an array with a negative integer, and it counts from the end. A negative index is assumed to be relative to the end of the array — that is, an index of -1 indicates the last element of the array, -2 is the next to last element in the array, and so on.
– You can also index arrays with a pair of numbers, [start, count]. This returns a new array consisting of references to count objects starting at position start.
– You can index arrays using ranges, in which start and end positions are separated by two or three periods. The two-period form includes the end position, and the three-period form does not. remove Modifying elements in array – The [ ] operator has a corresponding [ ]= operator, which lets you set elements in the array. If used with a single integer index, the element at that position is replaced by whatever is on the right side of the assignment. Any gaps that result will be filled with nil.
– If the index to [ ]= is two numbers (a start and a length) or a range, then those elements in the original array are replaced by whatever is on the right side of the assignment. If the length is zero, the right side is inserted into the array before the start position; no elements are removed. If the right side is itself an array, its elements are used in the replacement. The array size is automatically adjusted if the index selects a different number of elements than are available on the right side of the assignment.
| arraysa = [ 1, 'cat', 3.14 ] # create array with three elements
a[0] #-> 1 access the first element
a[2] = nil # set the third element
a #-> [1, "cat", nil]
arr = [ fred, 10, 3.14, "This is a string", barney("pebbles"), ]
%w( first sec\ ond ) #-> ["first", "sec ond"]
b = Array.new # array constructor
b.class #-> Array
b.length #-> 0
b[0] = "second"
b[1] = "array"
b #-> ["second", "array"]
c = [] # array short constructor
c.class #-> Array
string to arraya = %w{ ant bee cat dog elk }
a[0] #--> "ant"
a[3] #--> "dog"
ranges to array(1...10).to_a #-> [1, 2, 3, 4, 5, 6, 7, 8, 9]
('bar'..'bat').to_a #-> ["bar", "bas", "bat"]
|
| |
Array.[](*args) → array Creates new array populated with the given objects Array.new(size=0, obj=nil) → array Creates new array with size copies of obj (that is, size references to the same obj) Array.new(array) → array Creates copy of the array passed as a parameter (the array is generated by calling #to_ary on the parameter). Array.new(size) {|index| block } → arrayNew array of the given size is created. Each element in this array is calculated by passing the element’s index to the given block and storing the return value.
| SamplesArray.[]( 1, 'a', /^A/ ) #-> [1, "a", /^A/]
Array[ 1, 'a', /^A/ ] #-> [1, "a", /^A/]
[ 1, 'a', /^A/ ] #-> [1, "a", /^A/]
Array.new #-> []
Array.new(2) #-> [nil, nil]
Array.new(5, "A") #-> ["A", "A", "A", "A", "A"]
# only one copy of the object is created
a = Array.new(2, Hash.new) #-> a = [{}, {}]
a[0]['cat'] = 'feline' #-> a = [{"cat"=>"feline"}, {"cat"=>"feline"}]
a[1]['cat'] = 'Felix' #-> a = [{"cat"=>"Felix"}, {"cat"=>"Felix"}]
# here multiple copies are created
a = Array.new(2) { Hash.new } #-> a = [{}, {}]
a[0]['cat'] = 'feline' #-> a = [{"cat"=>"feline"}, {}]
squares = Array.new(5) {|i| i*i} #-> [0, 1, 4, 9, 16]
copy = Array.new(squares) #-> [0, 1, 4, 9, 16]
|
array &, intersection, set intersection array_1 & array_2 → array Intersection — returns a new array containing elements common to the two arrays, with no duplicates.
| Sample[1, 1, 3, 5] & [1, 2, 3] #-> [1, 3]
|
* array, array *, repetition array * int → array Returns a new array built by concatenating the int copies of self.
| Sample[1, 2, 3] * 3 #-> [1, 2, 3, 1, 2, 3, 1, 2, 3]
|
* array, array * array * str → string Equivalent to array.join(str)
| Sample[1, 2, 3] * "," #-> "1,2,3"
['12', '34', '5', '231'].join(", ") #-> "12, 34, 5, 231"
|
+ array, array + array_1 + array_2 → array Concatenation — returns a new array built by concatenating the two arrays together to produce a third array.
| Sample[1, 2, 3] + [4, 5] #-> [1, 2, 3, 4, 5]
|
- array, array - array_1 - array_2 → array Difference — returns a new array that is a copy of the original array, removing any items that also appear in other_array.
(If you need set-like behavior, see the library class Set.)
| Sample[1, 1, 2, 2, 3, 3, 4, 5] - [1, 2, 4] #-> [3, 3, 5]
|
<< array, array<<, push array << obj → array Append — Pushes the given object on to the end of this array.
This expression returns the array itself, so several appends may be chained together.
| Sample[1, 2] << "c" << "d" << [3, 4] #-> [1, 2, "c", "d", [3, 4]]
|
<=>array, array<=> array_1 <=> array_2 → -1, 0, +1 Comparison — returns an integer (-1, 0, or +1) if this array_1 is less than, equal to, or greater than array_2.
Each object in each array is compared (using <=>). If any value isn’t equal, then that inequality is the return value. If all the values found are equal, then the return is based on a comparison of the array lengths. Thus, two arrays are “equal” according to Array#<=> if and only if they have the same length and the value of each element is equal to the value of the corresponding element in the other array.
| Sample["a", "a", "c"] <=> ["a", "b", "c"] #-> -1
[1, 2, 3, 4, 5, 6] <=> [1, 2] #-> +1
|
== array, array == array_1 == array_2 → bool Equality — Two arrays are equal if they contain the same number of elements and if each element is equal to (according to Object.==) the corresponding element in the other array.
| Sample["a", "c"] == ["a", "c", 7] #-> false
["a", "c", 7] == ["a", "c", 7] #-> true
["a", "c", 7] == ["a", "d", "f"] #-> false
|
| Array for samplesa = ["a", "b", "c", "d", "e"]
|
.at, .slice array[index] → obj or nil
array.at(index) → obj or nil (synonym)
array.slice(index) → obj or nil (synonym) Returns the element at index.
Negative indices count backward from the end of the array (-1 is the last element).
Returns nil if the index (or starting index) are out of range.
| Samplea[2] + a[0] + a[1] #-> "cab"
a[5] #-> nil
a[6] #-> nil
a.at(0) #=> "a"
a.at(-1) #=> "e"
-1 array, -1 index, array -1 array indexation (-1 = the last)a = [1, 3, 5, 7, 9]
a[1] #-> 3
a[2] #-> 5
a[-1] #-> 9
a[99] #-> nil
|
array[start, length] → array or nil
array.slice(start, length) → array or nil (synonym) Returns a subarray starting at start and continuing for length elements
| Samplea[1, 2] #-> ["b", "c"]
a[-3, 3] #-> ["c", "d", "e"]
a[5, 1] #-> []
subarray – arr[start, count]a = [ 1, 3, 5, 7, 9 ]
a[1, 3] #-> [3, 5, 7]
a[3, 1] #-> [7]
a[3, 2] #-> [7, 9]
|
subarray by range array[range] → array or nil
array.slice(range) → array or nil (synonym) Returns a subarray specified by range
| Samplea[1..3] #-> ["b", "c", "d"]
a[4..7] #-> ["e"]
a[6..10] #-> nil
a[5..10] #-> []
subarray – two-period three-perioda = [ 1, 3, 5, 7, 9 ]
a[1..3] #-> [3, 5, 7]
a[1...3] #-> [3, 5]
a[3..3] #-> [7]
a[3..1] #-> []
|
array[index] = obj → obj
array[start, length] = obj or array or nil → obj or array or nil
array[range] = obj or array or nil → obj or array or nil Sets the element at index, or replaces a subarray starting at start and continuing for length elements, or replaces a subarray specified by range. If indices are greater than the current capacity of the array, the array grows automatically. A negative indices will count backward from the end of the array. Inserts elements if length is zero. If nil is used in the second and third form, deletes elements from self. An IndexError is raised if a negative index points past the beginning of the array. See also Array#push, and Array#unshift.
| Samplea = Array.new
a[4] = "4"; #-> [nil, nil, nil, nil, "4"]
a[0, 3] = ['a', 'b', 'c'] #-> ["a", "b", "c", nil, "4"]
a[1..2] = [1, 2] #-> ["a", 1, 2, nil, "4"]
a[0, 2] = "?" #-> ["?", 2, nil, "4"]
a[0..2] = "A" #-> ["A", "4"]
a[-1] = "Z" #-> ["A", "Z"]
a[1..-1] = nil #-> ["A"]
set elements in arraya = [1, 3, 5, 7, 9]
a[1] = "bat" #-> [1, "bat", 5, 7, 9]
a[2] = "cat" #-> [1, "bat", "cat", 7, 9]
a[3] = [9, 8] #-> [1, "bat", "cat", [9, 8], 9]
a[6] = 99 #-> [1, "bat", "cat", [9, 8], 9, nil, 99]
array splice, insert, splice set ranges elements in array, replacing elementsa = [ 1, 3, 5, 7, 9 ] #-> [1, 3, 5, 7, 9]
a[2, 2] = ’cat’ #-> [1, 3, "cat", 9]
a[2, 0] = ’dog’ #-> [1, 3, "dog", "cat", 9] inserting elements
a[1, 1] = [ 9, 8, 7 ] #-> [1, 9, 8, 7, "dog", "cat", 9]
a[0..3] = [] #-> ["dog", "cat", 9] removing elements
a[5..6] = 99, 98 #-> ["dog", "cat", 9, nil, nil, 99, 98]
|
.assoc array.assoc(obj) → array or nil Searches through an array whose elements are also arrays comparing obj with the first element of each contained array using obj.==. Returns the first contained array that matches (that is, the first associated array), or nil if no match is found. See also Array#rassoc.
| Samples1 = ["colors", "red", "blue", "green"]
s2 = ["letters", "a", "b", "c"]
s3 = "foo"
a = [s1, s2, s3]
a.assoc("letters") #-> ["letters", "a", "b", "c"]
a.assoc("red") #-> nil
a.assoc("foo") #-> nil
|
.choice array.choice → obj Choose a random element from an array.
| Samplea = ["a", "b", "c", "d", "e"]
a.choice #-> "e"
a.choice #-> "a"
a.choice #-> "b"
a = []
a.choice #-> nil
|
.clear array.clear → array Removes all elements from array.
| Samplea = ["a", "b", "c"]
a.clear #-> []
|
.collect, .map array.collect {|item| block } → array
array.map {|item| block } → arrayReturns a new array by invoking block once for every element, passing each element as a parameter to block.
The result of block is used as the given element in the new array. .collect!, .map! array.collect! {|item| block } → array
array.map! {|item| block } → arrayInvokes block once for each element of array, replacing the element with the value returned by block.
| collecta = ["a", "b", "c", "d"]
a.collect {|x| x + "!" } #-> ["a!", "b!", "c!", "d!"]
a #-> ["a", "b", "c", "d"]
collect!a = ["a", "b", "c", "d"]
a.collect! {|x| x + "!" } #-> ["a!", "b!", "c!", "d!"]
a #-> ["a!", "b!", "c!", "d!"]
|
.combination array.combination(n) { |c| block } → array
array.combination(n) → enumeratorWhen invoked with a block, yields all combinations of length n of elements from array and then returns array itself. The implementation makes no guarantees about the order in which the combinations are yielded.
When invoked without a block, returns an enumerator object instead.
| combinationa = [1, 2, 3, 4]
a.combination(1).to_a #-> [[1],[2],[3],[4]]
a.combination(2).to_a #-> [[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]
a.combination(3).to_a #-> [[1,2,3],[1,2,4],[1,3,4],[2,3,4]]
a.combination(4).to_a #-> [[1,2,3,4]]
a.combination(0).to_a #-> [[]] # one combination of length 0
a.combination(5).to_a #-> [] # no combinations of length 5
|
.compact array.compact → array Returns a copy of array with all nil elements removed.
| compact["a", nil, "b", nil, "c", nil].compact #-> ["a", "b", "c"]
|
.compact! array.compact! → array or nil Removes nil elements from array. Returns nil if no changes were made.
| compact!["a", nil, "b", nil, "c"].compact! #-> ["a", "b", "c"]
["a", "b", "c"].compact! #-> nil
|
.concat array.concat(other_array) → array Appends the elements in other_array to self.
| concata = ["a", "b"]
a.concat( ["c", "d"] ) #-> ["a", "b", "c", "d"]
a #-> ["a", "b", "c", "d"]
|
.count, array count array.count → int
array.count(obj) → int
array.count {|item| block } → int Returns the number of elements.
If an argument is given, counts the number of elements which equals to obj.
If a block is given, counts the number of elements yielding a true value.
| counta = [1, 2, 4, 2]
a.count #-> 4
a.count(2) #-> 2
a.count {|x| x % 2 == 0} #-> 3
|
.cycle, array cycle array.cycle {|obj| block }
array.cycle(n) {|obj| block }Calls block for each element repeatedly n times or forever if none or nil is given.
If a non-positive number is given or the array is empty, does nothing.
Returns nil if the loop has finished without getting interrupted.
| cyclea = ["a", "b", "c"]
a.cycle {|x| puts x } # prints: a, b, c, a, b, c, ... (forever)
a.cycle(2) {|x| puts x } # prints: a, b, c, a, b, c
|
.delete, array delete, array delete elements, array elements deletion, delete all, delete by content match, delete from array array.delete(obj) → value of deleted element or nil
array.delete(obj) { block } → obj or nil Deletes items from self that are equal to obj. Deletes all matched items.
If the item is not found, returns nil.
If the optional code block is given, returns the result of block if the item is not found.
| deletea = ["a", "b", "b", "b", "c"]
a.delete("b") #-> "b"
a #-> ["a", "c"]
a.delete("z") #-> nil
a.delete("z") { "not found" } #-> "not found"
|
.delete_at, array delete element, array delete_at, delete at, delete by index, delete element from array array.delete_at(index) → value of deleted element or nil Deletes the element at the specified index, returning that element, or nil if the index is out of range.
See also array.slice!
| delete_ata = %w(ant bat cat dog)
a.delete_at(2) #-> "cat"
a #-> ["ant", "bat", "dog"]
a.delete_at(99) #-> nil
arr = [1, 2, 3]
arr.delete_at(1) #-> 2
arr #-> [1, 3]
|
.delete_if, array delete_if, delete if array.delete_if {|item| block } → arrayDeletes every element of self for which block evaluates to true.
| delete_ifa = ["a", "b", "c"]
a.delete_if {|x| x >= "b" } #-> ["a"]
|
.drop, array drop array.drop(n) → array Drops first n elements from array, and returns rest elements in an array.
Does not modify the original array.
| dropa = [1, 2, 3, 4, 5, 0]
a.drop(3) #-> [4, 5, 0]
a #-> [1, 2, 3, 4, 5, 0]
|
.drop_while, array drop_while array.drop_while {|item| block } → arrayDrops elements up to, but not including, the first element for which the block returns nil or false and returns an array containing the remaining elements.
Does not modify the original array.
| drop_whilea = [1, 2, 3, 4, 5, 0]
a.drop_while {|i| i < 3 } #-> [3, 4, 5, 0]
a #-> [1, 2, 3, 4, 5, 0]
|
.each, array each array.each {|item| block } → arrayCalls block once for each element in array, passing that element as a parameter.
Returns initial array.
| eacha = ["a", "b", "c"]
a.each {|x| print x, " -- " }
produces:
a -- b -- c --
|
.each_index, array each_index array.each_index {|index| block } → arraySame as array.each, but passes the index of the element instead of the element itself.
Returns initial array.
| each_indexa = ["a", "b", "c"]
a.each_index {|x| print x, " -- " }
produces:
0 -- 1 -- 2 --
|
.empty?, array empty? array.empty? → true or false Returns true if self array contains no elements.
| |
.eql?, array eql? array.eql?(other) → true or false Returns true if array and other are the same object, or are both arrays with the same content.
| |
.fetch, array fetch array.fetch(index) → obj
array.fetch(index, default ) → obj
array.fetch(index) {|index| block } → obj Tries to return the element at position index.
If the index lies outside the array, the first form throws an IndexError exception, the second form returns default, and the third form returns the value of invoking the block, passing in the index.
Negative values of index count from the end of the array.
| fetcha = [11, 22, 33, 44]
a.fetch(1) #-> 22
a.fetch(-1) #-> 44
a.fetch(4, 'cat') #-> "cat"
a.fetch(4) {|i| i*i } #-> 16
|
.fill, array fill array.fill(obj) → array
array.fill(obj, start [, length]) → array
array.fill(obj, range ) → array
array.fill {|index| block } → array
array.fill(start [, length] ) {|index| block } → array
array.fill(range) {|index| block } → array The first three forms set the selected elements of self (which may be the entire array) to obj.
- A start of nil is equivalent to zero.
- A length of nil is equivalent to self.length.
The last three forms fill the array with the value of the block. The block is passed the absolute index of each element to be filled.
| filla = ["a", "b", "c", "d"]
a.fill("x") #-> ["x", "x", "x", "x"]
a.fill("z", 2, 2) #-> ["x", "x", "z", "z"]
a.fill("y", 0..1) #-> ["y", "y", "z", "z"]
a.fill {|i| i*i } #-> [0, 1, 4, 9]
a.fill(-2) {|i| i*i*i } #-> [0, 1, 8, 27]
|
.index, array index array.index(obj) → int or nil
array.index {|item| block } → int or nil
This is an alias of array.find_index Returns the index of the first object in self such that is == to obj.
If a block is given instead of an argument, returns first object for which block is true. Returns nil if no match is found.
| indexa = ["a", "b", "c"]
a.index("b") #-> 1
a.index("z") #-> nil
a.index{|x| x=="b" } #-> 1
|
.first, array first, first n array.first → obj or nil
array.first(n) → array Returns the first element, or the first n elements of the array.
If the array is empty, the first form returns nil, and the second form returns an empty array.
| firsta = ["q", "r", "s", "t"]
a.first #-> "q"
a.first(1) #-> ["q"]
a.first(3) #-> ["q", "r", "s"]
|
.flatten, array flatten array.flatten → array
array.flatten(level) → array Returns a new array that is a one-dimensional flattening of this array (recursively). That is, for every element that is an array, extract its elements into the new array.
If the optional level argument determines the level of recursion to flatten.
| flattens = [1, 2, 3] #-> [1, 2, 3]
t = [4, 5, 6, [7, 8]] #-> [4, 5, 6, [7, 8]]
a = [s, t, 9, 10] #-> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
a.flatten #-> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
a = [1, 2, [3, [4, 5]]]
a.flatten(1) #-> [1, 2, 3, [4, 5]]
convert array to hash, hash, to_h, to_hash flattena1 = ['apple', 1, 'banana', 2]
h1 = Hash[*a1.flatten] #->{ 'apple' => 1, 'banana' => 2}
a2 = [['apple', 1], ['banana', 2]]
h2 = Hash[*a2.flatten] #->{ 'apple' => 1, 'banana' => 2}
|
.flatten!, array flatten! array.flatten! → array or nil
array.flatten!(level) → array or nil Flattens self in place.
Returns nil if no modifications were made (i.e., array contains no subarrays).
If the optional level argument determines the level of recursion to flatten.
| flatten!a = [1, 2, [3, [4, 5]]]
a.flatten! #-> [1, 2, 3, 4, 5]
a.flatten! #-> nil
a #-> [1, 2, 3, 4, 5]
a = [1, 2, [3, [4, 5]]]
a.flatten!(1) #-> [1, 2, 3, [4, 5]]
|
.frozen?, array frozen? array.frozen? → true or false Return true if this array is frozen (or temporarily frozen while being sorted).
| |
.hash, array hash array.hash → fixnum Compute a hash-code for this array.
Two arrays with the same content will have the same hash code (and will compare using eql?).
| |
.include?, array include?, includes? array.include?(obj) → true or false Returns true if the given object is present in array (that is, if any object == anObject), false otherwise.
| include?a = ["a", "b", "c"]
a.include?("b") #-> true
a.include?("z") #-> false
|
.indexes, .indices, array indexes array.indexes(i1, i2, ... iN) → array
array.indices(i1, i2, ... iN) → array Deprecated.
Use array.values_at
| |
.replace, array replace array.replace(array2) → array Replaces the contents of self with the contents of array2, truncating or expanding if necessary.
| replacea = ["a", "b", "c", "d", "e"]
a.replace(["x", "y", "z"]) #-> ["x", "y", "z"]
a #-> ["x", "y", "z"]
|
.insert, array insert array.insert(index, obj...) → array Inserts the given values before the element with the given index.
Or after the element if the given index is negative (or before if go from the end of array).
| inserta = %w{a b c d}
a.insert(2, 99) #-> ["a", "b", 99, "c", "d"]
a[-2] #-> "c"
a.insert(-2, 1, 2, 3) #-> ["a", "b", 99, "c", 1, 2, 3, "d"]
|
.inspect, array inspect array.inspect → string Create a printable version of array.
| |
.last, array last, last item, last n elements, last n items array.last → obj or nil
array.last(n) → array Returns the last element(s) of array.
If the array is empty, the first form returns nil.
| last["w", "x", "y", "z"].last #-> "z"
|
.length, .size, array length, array size array.length → int
array.size → int (alias) Returns length of array (number of elements). May be zero.
| length[1, 2, 3, 4, 5].length #-> 5
|
.collect, .map, array collect, array map array.collect {|item| block } → array
array.map {|item| block } → arrayInvokes block once for each element of self. Creates a new array containing the values returned by the block.
See also Enumerable#collect.
| collecta = ["a", "b", "c", "d"]
a.collect {|x| x + "!" } #-> ["a!", "b!", "c!", "d!"]
a #-> ["a", "b", "c", "d"]
|
arr.push(Object) → arr Appends the given argument(s) to the end of arr (as with a stack). arr.pop → obj or nil Removes the last element from arr and returns it, or nil if the array is empty (as with a stack).
| Array pusha = [ "a", "b", "c" ]
a.push("d", "e", "f") #-> ["a", "b", "c", "d", "e", "f"]
Array popa = [ "a", "m", "z" ]
a.pop #-> "z"
a #-> ["a", "m"]
|
.shift arr.shift → obj or nil
arr.shift(n) → newArray Returns the first element of self and removes it (shifting all other elements down by one).
Returns nil if the array is empty.
If a number n is given, returns an array of the first n elements (or less) just like array.slice!(0, n) does. .unshift arr.unshift(obj, ...) → anArray Prepends objects to the front of self, moving other elements upwards
| Samplesargs = [ "-m", "-q", "filename" ]
args.shift #=> "-m"
args #=> ["-q", "filename"]
args = [ "-m", "-q", "filename" ]
args.shift(2) #=> ["-m", "-q"]
args #=> ["filename"]
Samplea = [ "b", "c", "d" ]
a.unshift("a") #--> ["a", "b", "c", "d"]
a.unshift(1, 2) #--> [ 1, 2, "a", "b", "c", "d"]
|
arr.sort → Array
arr.sort {|a,b| block } → Array Returns a new array created by sorting arr.
Comparisons for the sort will be done using the <=> operator or using an optional code block.
The block implements a comparison between a and b, returning -1, 0, or +1. arr.sort! → arr
arr.sort! {|a,b| block } → arr Same as Array.sort, but modifies the receiver in place.
arr is effectively frozen while a sort is in progress.
| Array sorta = ["d", "a", "e", "c", "b"]
a.sort #-> ["a", "b", "c", "d", "e"]
a.sort {|x,y| y <=> x } #-> ["e", "d", "c", "b", "a"]
Array sort!a = [ "d", "a", "e", "c", "b" ]
a.sort! #-> ["a", "b", "c", "d", "e"]
a #-> ["a", "b", "c", "d", "e"]
|
sort_by array.sort_by {block} → Arraysort array by some parameters
| rand, sort, sort_by sort_byarray.sort_by{ rand } #=> [3, 6, 7, 1, 4, 5, 2]
|
arr.reverse → Array Returns a new array using arr's elements in reverse order. arr.reverse! → arr or nil Same as reverse, but returns nil if arr is unchanged (arr.length is zero or one).
| reverse["a", "b", "c"].reverse #-> ["c", "b", "a"]
[1].reverse #-> [1]
reverse!a = ["a", "b", "c"]
a.reverse! #-> ["c", "b", "a"]
a #-> ["c", "b", "a"]
[1].reverse! #-> nil
|
bckwards reverse_each Same as Array.each, but traverses arr in reverse order.
| reverse_eacha = ["a", "b", "c"]
a.reverse_each {|x| print x, " " }
produces:
c b a
|
array, partition, split .partition split array
| array, partition, split split arrayarray = [1, 2, 3, 4, 5, 6, 7, 8, 9]
array.partition{ |x| (x % 3).zero? } #=> [[3, 6, 9], [1, 2, 4, 5, 7, 8]]
array = [1, 2, 3, 4, 5, 6, 7, 8, 9]
one, two = array.partition{ |x| (x % 3).zero? }
one #=> [3, 6, 9]
two #=> [1, 2, 4, 5, 7, 8]
|
all?, any?, logical iterators logical iterators logical iterators
| all?, any? logical iterationsarray = [2, 2, 2, 2]
array.all?{ |elem| elem == 2 } #=> true
array = [2, 3, 7, 2]
array.any?{ |elem| elem > 9 } #=> false
|
.to_a Converts a range to a list
| |
| |
about Hashes (sometimes known as associative arrays, maps, or dictionaries) are similar to arrays in that they are indexed collections of object references. However, while you index arrays with integers, you can index a hash with objects of any type: strings, regular expressions, and so on. When you store a value in a hash, you actually supply two objects — the index, normally called the key, and the value. You can subsequently retrieve the value by indexing the hash with the same key. The values in a hash can be objects of any type.
a hash by default returns nil when indexed by a key it doesn’t contain. Sometimes you’llwant to change this default. For example, if you’re using a hash to count the number of times each key occurs, it’s convenient to have the default value be zero. This is easily done by specifying a default value when you create a new, empty hash.
Compared with arrays, hashes have one significant advantage: they can use any object as an index. However, they also have a significant disadvantage: their elements are not ordered, so you cannot easily use a hash as a stack or a queue. Also thes are not so efficient as arrays.
Hash does not support multiple keys with the same value
| hashinst_section = {
'cello' => 'string',
'clarinet' => 'woodwind',
'drum' => 'percussion',
}
h = {}
h.length #-> 0
h['dog'] #-> nil
hashh = { 'dog' => 'canine', 'cat' => 'feline', 'donkey' => 'asinine' }
h.length #-> 3 length
h['dog'] #-> "canine"
h['cow'] = 'bovine'
h[12] = 'dodecine'
h['cat'] = 99
h #-> {"cow"=>"bovine", "cat"=>99, 12=>"dodecine",
# "donkey"=>"asinine", "dog"=>"canine"}
|
Hash[ [ key => value ]* ] → Hash Creates a new hash populated with the given objects.
– Equivalent to the literal { key, value, ... }.
– Keys and values occur in pairs, so there must be an even number of arguments.
| Hash[Hash["a", 100, "b", 200] #-> {"a"=>100, "b"=>200}
Hash["a" => 100, "b" => 200] #-> {"a"=>100, "b"=>200}
{ "a" => 100, "b" => 200 } #-> {"a"=>100, "b"=>200}
|
Hash.new( Object=nil ) → Hash Returns a new, empty hash.
– If Object is specified, it will be used as the default value.
| Hash.newh = Hash.new("Go Fish")
h["a"] = 100
h["b"] = 200
h["a"] #-> 100
h["c"] #-> "Go Fish"
0 by defaul instead NILhistogram = Hash.new(0)
histogram['key1'] --> 0
histogram['key1'] = histogram['key1'] + 1
histogram['key1'] --> 1
|
hsh[ aKeyObject ] → aValueObject Element Reference
– Retrieves the aValueObject stored for aKeyObject.
– If not found, returns the default value.
| Element Referenceh = { "a" => 100, "b" => 200 }
h["a"] #-> 100
h["c"] #-> nil
|
hsh[ aKeyObject ] = aValueObject → aValueObject
hsh.store( aKeyObject, aValueObject ) → aValueObject (Synonym) Element Assignment
– Associates the value given by aValueObject with the key given by aKeyObject. – aKeyObject should not have its value changed while it is in use as a key (a String passed as a key will be duplicated and frozen).
| Element Assignmenth = { "a" => 100, "b" => 200 }
h["a"] = 9
h["c"] = 4
h #-> {"a"=>9, "b"=>200, "c"=>4}
|
hsh == anOtherHash → true or false Equality
– Two hashes are equal if they each contain the same number of keys and if each key-value pair is equal to (according to Object#== ) the corresponding elements in the other hash.
| Equalityh1 = { "a" => 1, "c" => 2 }
h2 = { "a" => 1, "c" => 2, 7 => 35 }
h3 = { "a" => 1, "c" => 2, 7 => 35 }
h4 = { "a" => 1, "d" => 2, "f" => 35 }
h1 == h2 #-> false
h2 == h3 #-> true
h3 == h4 #-> false
|
hsh.default → Object Returns the "default value" that is, the value returned for a key that does not exist in the hash.
– Defaults to nil. hsh.default = Object → hsh Sets the "default value"
| defaulth = { "a" => 100, "b" => 200 }
h.default = "Go fish"
h.default #-> Go fish
h["a"] #-> 100
h["z"] #-> "Go fish"
|
delete key, delete_key, hash delete, hsh delete hsh.delete( aKeyObject ) → aValueObject
hsh.delete( aKeyObject ) {| aKeyObject | block } → aValueObject Deletes and returns a key-value pair from hsh whose key is equal to aKeyObject.
– If the key is not found, returns the default value.
– If the optional code block is given and the key is not found, pass in the key and return the result of block.
| deleteh = { "a" => 100, "b" => 200 }
h.delete("a") #-> 100
h.delete("z") #-> nil
h.delete("z") { |el| "#{el} not found" } #-> "z not found"
|
delete if hsh.delete_if {| key, value | block } → hshDeletes every key-value pair from hsh for which block evaluates to true.
| delete_ifh = { "a" => 100, "b" => 200, "c" => 300 }
h.delete_if {|key, value| key >= "b" } #->{"a"=>100}
|
hash sort, sort hash hsh.sort → Array
hsh.sort {|a, b| block } → Array Converts hsh to a nested array of [key, value] arrays and sorts it, using Array.sort.
| Hash sorth = { "a" => 20, "b" => 30, "c" => 10 }
h.sort #-> [["a", 20], ["b", 30], ["c", 10]]
h.sort {|a,b| a[1]<=>b[1]} #-> [["c", 10], ["a", 20], ["b", 30]]
Hash[h.sort {|a,b| a[1]<=>b[1]}] #-> {"c" => 10, "b" => 30, "a" => 20}
|
hsh.clear → hsh Removes all key-value pairs from hsh.
| clearh = {"a" => 100, "b" => 200}
h.clear #-> {}
|
.each, each hash, each hsh hsh.each {| key, value | block } → hsh
hsh.each_pair {| key, value | block } → hsh (Synonym)Calls block once for each key in hsh, passing the key and value as parameters.
| eachh = { "a" => 100, "b" => 200 }
h.each {|key, value| print key, " is ", value, "\n" }
produces:
a is 100
b is 200
|
hsh.each_key {| key | block } → hshCalls block once for each key in hsh, passing the key as a parameter.
| each_keyh = { "a" => 100, "b" => 200 }
h.each_key {|key| puts key }
produces:
a
b
|
hsh.each_value {| value | block } → hshCalls block once for each key in hsh, passing the value as a parameter.
| each_valueh = { "a" => 100, "b" => 200 }
h.each_value {|value| puts value }
produces:
100
200
|
hsh.empty? → true or false Returns true if hsh contains no key-value pairs.
| |
hsh.fetch( aKeyObject [, aDefObject ] ) → Object
hsh.fetch( aKeyObject ) {| aKeyObject | block } → Object Returns a value from the hash for the given key.
If the key can't be found, there are several options:
– With no other arguments, it will raise an IndexError exception;
– if aDefObject is given, then that will be returned;
– if the optional code block is specified, then that will be run and its result returned.
| fetchh = { "a" => 100, "b" => 200 }
h.fetch("a") #-> 100
h.fetch("z", "go fish") #-> "go fish"
h.fetch("z") { |el| "go fish, #{el}"} #-> "go fish, z"
The following example shows that an exception is raised if the key is not found and a default value is not supplied.h = { "a" => 100, "b" => 200 }
h.fetch("z")
produces:
prog.rb:2:in `fetch': key not found (IndexError)
from prog.rb:2
|
has key, hash include, hsh include hsh.has_key?( aKeyObject ) → true or false
Synonyms:
hsh.include?( aKeyObject ) → true or false
hsh.key?( aKeyObject ) → true or false
hsh.member?( aKeyObject ) → true or false Returns true if the given key is present in hsh.
| has_key?h = { "a" => 100, "b" => 200 }
h.has_key?("a") #-> true
h.has_key?("z") #-> false
|
hsh.has_value?( aValueObject ) → true or false
hsh.value?( aValueObject ) → true or false (Synonym) Returns true if the given value is present for some key in hsh.
| has_value?h = { "a" => 100, "b" => 200 }
h.has_value?(100) #-> true
h.has_value?(999) #-> false
|
hsh.index( aValueObject ) → aKeyObject Returns the key for a given value.
– If not found, returns the default value.
| 11 indexh = { "a" => 100, "b" => 200 }
h.index(200) #-> "b"
h.index(999) #-> nil
|
hsh.indexes( [ key ]+ ) → Array
hsh.indices( [ key ]+ ) → Array (Synonym) Returns a new array consisting of values for the given key(s).
– Will insert the default value for keys that are not found.
| indexesh = { "a" => 100, "b" => 200, "c" => 300 }
h.indexes("a", "c") #-> [100, 300]
h.indexes("a", "c", "z") #-> [100, 300, nil]
|
hsh.invert → Hash Returns a new hash created by using hsh's values as keys, and the keys as values.
| inverth = { "n" => 100, "m" => 100, "y" => 300, "d" => 200, "a" => 0 }
h.invert #-> {0=>"a", 100=>"n", 200=>"d", 300=>"y"}
|
hsh.keys → Array Returns a new array populated with the keys from this hash.
| keysh = { "a" => 100, "b" => 200, "c" => 300, "d" => 400 }
h.keys #-> ["a", "b", "c", "d"]
|
hsh.values → Array Returns a new array populated with the values from hsh.
| valuesh = { "a" => 100, "b" => 200, "c" => 300 }
h.values #-> [100, 200, 300]
|
hash length, length hash hsh.length → Fixnum
hsh.size → Fixnum (Synonym) Returns the number of key-value pairs in the hash.
| lengthh = { "d" => 100, "a" => 200, "v" => 300, "e" => 400 }
h.length #-> 4
h.delete("a") #-> 200
h.length #-> 3
|
hsh.rehash → hsh Rebuilds the hash based on the current hash values for each key.
– If values of key objects have changed since they were inserted, this method will reindex hsh.
– If Hash.rehash is called while an iterator is traversing the hash, an IndexError will be raised in the iterator.
| rehasha = [ "a", "b" ]
c = [ "c", "d" ]
h = { a => 100, c => 300 }
h[a] #-> 100
a[0] = "z"
h[a] #-> nil
h.rehash #-> {["z", "b"]=>100, ["c", "d"]=>300}
h[a] #-> 100
|
hsh.reject {| key, value | block } → HashSame as Hash.delete_if, but works on (and returns) a copy of the hsh.
– Equivalent to hsh.dup.delete_if hsh.reject! {| key, value | block } → hsh or nilEquivalent to Hash.delete_if, but returns nil if no changes were made.
| |
hsh.replace( anOtherHash ) → hsh Replaces the contents of hsh with the contents of anOtherHash.
| replaceh = { "a" => 100, "b" => 200 }
h.replace({ "c" => 300, "d" => 400 }) #->{"c"=>300, "d"=>400}
|
hsh.shift → Array or nil Removes a key-value pair from hsh and returns it as the two-item array [ key, value ], or nil if the hash is empty.
| shifth = {1 => "a", 2 => "b", 3 => "c"}
h.shift #-> [1, "a"]
h #-> {2=>"b", 3=>"c"}
|
hsh.to_a → Array Converts hsh to a nested array of [ key, value ] arrays.
| to_ah = {"c" => 300, "a" => 100, "d" => 400, "c" => 300}
h.to_a #-> [["a", 100], ["c", 300], ["d", 400]]
|
hsh.to_s → String Converts hsh to a string by converting the hash to an array of [ key, value ] pairs and then converting that array to a string using Array.join with the default separator.
| to_sh = { "c" => 300, "a" => 100, "d" => 400, "c" => 300 }
h.to_s #->"a100c300d400"
|
hsh.update( anOtherHash ) → hsh
hsh.merge!( anOtherHash ) → hsh Adds the contents of anOtherHash to hsh, overwriting entries with duplicate keys with those from anOtherHash.
hsh will be modified.
| updateh1 = { "a" => 100, "b" => 200 }
h2 = { "b" => 254, "c" => 300 }
h1.update(h2) #->{"a"=>100, "b"=>254, "c"=>300}
inlineh1 = {:a => 100, :b => 200}
h1.update(:b => 254, :c => 300) #-> {:b=>254, :c=>300, :a=>100}
|
hash, merge hasH1.merge(hasH2) → Hash Same as .update, but original hasH1 will not be modified.
| hash, merge mergehasH1 = {:a => 1, :b => 2} #=> {:a=>1, :b=>2}
hasH2 = {:b => 3, :c => 4} #=> {:b=>3, :c=>4}
hasH1.merge(hasH2) #=> {:a=>1, :b=>3, :c=>4}
hasH2.merge(hasH1) #=> {:a=>1, :b=>2, :c=>4}
|
| |
#, Substitutions "...#{expr}...#$globalExp...#@classExp...#@@const..."Double-quoted strings support a boatload more escape sequences.
The most common is probably \n, the newline character.
In addition, you can substitute the value of any Ruby code into a string using the sequence #{expr}.
If the code is just a global variable, a class variable, or an instance variable, you can omit the braces.
| Substitutesr = 'E'
$glob = 'G'
@inst = 'I'
@@const = 'C'
puts "...#{r}...#{1+2}...#$glob...#@inst...#@@const..."
produces: "...E...3...G...I...C..."
Substitutes"Seconds/day: #{24*60*60}" #-> Seconds/day: 86400
"#{'Ho! '*3}Merry Christmas!" #-> Ho! Ho! Ho! Merry Christmas!
"This is line #$." #-> This is line 3
puts "now is #{ def the(a)
'the ' + a
end
the('time')
} for all good coders..."
produces:
now is the time for all good coders...
|
quoting, single-quoted %q and %Q Start delimited single- and double-quoted strings (you can think of %q as a thin quote ', and %Q as a thick quote ").
– The character following the q or Q is the delimiter. If it is an opening bracket "[", brace "{", parenthesis "(", or less-than sign "<", the string is read until the matching close symbol is found. Otherwise the string is read until the next occurrence of the same delimiter.
– The delimiter can be any nonalphanumeric or nonmultibyte character.
| Quoting%q/general 'singlequoted-string'/ #-> general 'singlequoted-string'
%Q!general "doublequoted-string"! #-> general "doublequoted-string"
%Q{Seconds/day: #{24*60*60}} #-> Seconds/day: 86400
|
About string Ruby strings are simply sequences of 8-bit bytes.
They normally hold printable characters, but that is not a requirement; a string can also hold binary data.
Strings are objects of class String.
| escaping escape using "\"'escape using "\\"' #-> escape using "\"
'That\'s right' #-> That's right
usingline = "/jazz/j00319.mp3 | 2:58 | Louis Armstrong | Wonderful World"
file, length, name, title = line.chomp.split(/\s*\|\s*/)
name.squeeze!(" ") # removing extra spaces
mins, secs = length.scan(/\d+/)
puts "#{name} - #{title} (#{mins.to_i*60+secs.to_i})"
produces:
Louis Armstrong - Wonderful World (178)
|
mixins Comparable: <, <=, ==, >=, >, between?
Enumerable: collect, detect, each_with_index, entries, find, find_all, grep, include?, map, max, member?, min, reject, select, sort, to_a
| |
str % arg → String Format
Uses str as a format specification, and returns the result of applying it to arg.
– If the format specification contains more than one substitution, then arg must be an Array containing the values to be substituted.
– See Kernel.sprintf for details of the format string.
| usage"%05d" % 123 #-> "00123"
"%-5s: %08x" % ["ID", self.id] #-> "ID : 200e1670"
|
str * Integer → String Copy
Returns a new String containing Integer copies of the receiver.
| sample"Ho! " * 3 #-> "Ho! Ho! Ho! "
|
str + String → NewString Concatenation
Returns a new String containing String concatenated to str.
| sample"Hello from " + self.to_s #-> "Hello from main"
|
str << Fixnum → str
str << Object → str
synonyms
str.concat( Fixnum ) → str
str.concat( Object ) → str Append
Concatenates the given object to str.
If the object is a Fixnum between 0 and 255, it is converted to a character before concatenation.
| samplea = "hello "
a << "world" #-> "hello world"
a << 33 #-> "hello world!"
a #-> "hello world!"
|
str <=> String → -1, 0, +1 Comparison
Returns -1 if str is less than, 0 if str is equal to, and +1 if str is greater than String.
– If the strings are of different lengths, and the strings are equal when compared up to the shortest length, then the longer string is considered greater than the shorter one.
– If the variable $= is false, the comparison is based on comparing the binary values of each character in the string.
– If $= is not false, then the comparison is case insensitive. [The locale is ignored when case-insensitive comparisons are performed, so "\"o" will not match "\"O".]
– <=> is the basis for the methods <, <=, >, >=, and between?, included from module Comparable.
| sample"abcdef" <=> "abcde" #-> 1
"abcdef" <=> "abcdef" #-> 0
"abcdef" <=> "abcdefg" #-> -1
"abcdef" <=> "ABCDEF" #-> 1
$= = true
"abcdef" <=> "ABCDEF" #-> 0
|
str == Object → true or false
str === Object → true or false (Synonym) Equality
– If Object is not a String, returns false. Otherwise, returns true if str <=> Object returns zero.
– The method String.== does not use Comparable.==
| |
str =~ Object → Fixnum or nil Match
– If Object is a Regexp or a String, uses it as a pattern to match against str.
– Returns the position the match starts, or nil if there is no match.
– Otherwise, invokes Object.=~, passing str as an argument.
– The default =~ in Object returns false.
| sample"cat o' 9 tails" =~ "\\d" #-> 7
"cat o' 9 tails" =~ /\d/ #-> 7
"cat o' 9 tails" =~ 9 #-> false
|
[], substring str[Fixnum] → Fixnum or nil
str[Fixnum, Fixnum] → String or nil
str[Range] → String or nil
str[Regexp] → String or nil
str[String] → String or nil Element Reference
– If passed a single Fixnum, returns the code of the character at that position.
– If passed two Fixnum objects, returns a substring starting at the offset given by the first, and a length given by the second.
– If given a range, a substring containing characters at offsets given by the range is returned.
– In all three cases, if an offset is negative, it is counted from the end of str.
– Returns nil if the initial offset falls outside the string, the length is negative, or the beginning of the range is greater than the end.
– If a Regexp is supplied, the matching portion of str is returned.
– If a String is given, that string is returned if it occurs in str.
– In both cases, nil is returned if there is no match.
| samplesa = "hello there"
a[1] #-> 101
a[1,3] #-> "ell"
a[1..3] #-> "ell"
a[-3,2] #-> "er"
a[-4..-2] #-> "her"
a[-2..-4] #-> nil
a[/th[aeiou]/] #-> "the"
a["lo"] #-> "lo"
a["bye"] #-> nil
|
str[Fixnum] = Fixnum
str[Fixnum] = String
str[Fixnum, Fixnum] = String
str[Range] = String
str[Regexp] = String
str[String] = String Element Assignment
– Replaces some or all of the content of str.
– The portion of the string affected is determined using the same criteria as String.[]
– If the replacement string is not the same length as the text it is replacing, the string will be adjusted accordingly.
– The forms that take a Fixnum will raise an IndexError if the value is out of range; the Range form will raise a RangeError, and the Regexp and String forms will silently ignore the assignment.
| samplesa = "hello"; a[2] = 96; a #-> "he`lo"
a = "hello"; a[2, 4] = "xyz"; a #-> "hexyz"
a = "hello"; a[-4, 2] = "xyz"; a #-> "hxyzlo"
a = "hello"; a[2..4] = "xyz"; a #-> "hexyz"
a = "hello"; a[-4..-2] = "xyz"; a #-> "hxyzo"
a = "hello"; a[/[el]+/] = "xyz"; a #-> "hxyzo"
a = "hello"; a["l"] = "xyz"; a #-> "hexyzlo"
a = "hello"; a["ll"] = "xyz"; a #-> "hexyzo"
a = "hello"; a["bad"] = "xyz"; a #-> "hello"
a = "hello"; a[2, 0] = "xyz"; a #-> "hexyzllo"
|
String functions in Ruby String methods Source: ellho.net/solutions/ruby-string-functions-in-ruby.html
To change case:
capitalize - first character to upper, rest to lower
downcase - all to lower case
swapcase - changes the case of all letters
upcase - all to upper case
To rejustify:
center - add white space padding to center string
ljust - pads string, left justified
rjust - pads string, right justified
To trim:
chop - remove last character
chomp - remove trailing line separators
squeeze - reduces successive equal characters to singles
strip - deletes leading and trailing white space
To examine:
count - return a count of matches
empty? - returns true if empty
include? - is a specified target string present in the source?
index - return the position of one string in another
length or size - return the length of a string
rindex - returns the last position of one string in another
slice - returns a partial string
To encode and alter:
crypt - password encryption
delete - delete an intersection
dump - adds extra \ characters to escape specials
hex - takes string as hex digits and returns number
next or succ - successive or next string (eg ba → bb)
oct - take string as octal digits and returns number
replace - replace one string with another
reverse - turns the string around
slice! - DELETES a partial string and returns the part deleted
split - returns an array of partial strings exploded at separator
sum - returns a checksum of the string
to_f and to_i - return string converted to float and integer
tr - to map all occurrences of specified char(s) to other char(s)
tr_s - as tr, then squeeze out resultant duplicates
unpack - to extract from a string into an array using a template
To iterate:
each - process each character in turn
each_line - process each line in a string
each_byte - process each byte in turn
upto - iterate through successive strings (see "next" above)
| |
str.slice( Fixnum ) → Fixnum or nil
str.slice( Fixnum, Fixnum ) → String or nil
str.slice( Range ) → String or nil
str.slice( Regexp ) → String or nil
str.slice( String ) → String or nil Synonyms for str[]
| slicea = "hello there"
a.slice(1) #-> 101
a.slice(1,3) #-> "ell"
a.slice(1..3) #-> "ell"
a.slice(-3,2) #-> "er"
a.slice(-4..-2) #-> "her"
a.slice(-2..-4) #-> nil
a.slice(/th[aeiou]/) #-> "the"
a.slice("lo") #-> "lo"
a.slice("bye") #-> nil
|
str.slice!( Fixnum ) → Fixnum or nil
str.slice!( Fixnum, Fixnum ) → String or nil
str.slice!( Range ) → String or nil
str.slice!( Regexp ) → String or nil
str.slice!( String ) → String or nil Deletes the specified portion from str, and returns the portion deleted.
– The forms that take a Fixnum will raise an IndexError if the value is out of range; the Range form will raise a RangeError, and the Regexp and String forms will silently ignore the assignment.
| slice!string = "this is a string"
string.slice!(2) #-> 105
string.slice!(3..6) #-> " is "
string.slice!(/s.*t/) #-> "sa st"
string.slice!("r") #-> "r"
string #-> "thing"
|
first uppercase, upper first str.capitalize → String Returns a copy of str with the first character converted to uppercase and the remainder to lowercase. str.capitalize! → str or nil Modifies str by converting the first character to uppercase and the remainder to lowercase.
– Returns nil if no changes are made.
| capitalize"hello".capitalize #-> "Hello"
"HELLO".capitalize #-> "Hello"
"123ABC".capitalize #-> "123abc"
capitalize!a = "hello"
a.capitalize! #-> "Hello"
a #-> "Hello"
a.capitalize! #-> nil
|
str.downcase → String Returns a copy of str with all uppercase letters replaced with their lowercase counterparts.
– The operation is locale insensitive
– Only characters "A" to "Z" are affected. str.downcase! → str or nil Downcases the contents of str, returning nil if no changes were made.
| downcase"hEllO".downcase #-> "hello"
|
to uppercase str.upcase → String Returns a copy of str with all lowercase letters replaced with their uppercase counterparts.
– The operation is locale insensitive
– Only characters "a" to "z" are affected. str.upcase! → str or nil Upcases the contents of str, returning nil if no changes were made.
| upcase"hEllO".upcase #-> "HELLO"
|
str.center( Integer ) → String If Integer is greater than the length of str
– returns a new String of length Integer with str centered between spaces
– otherwise, returns str.
| center"hello".center(4) #-> "hello"
"hello".center(20) #-> " hello "
|
str.ljust( Integer ) → String If Integer is greater than the length of str, returns a new String of length Integer with str left justified and space padded; otherwise, returns str.
| ljust"hello".ljust(4) #-> "hello"
"hello".ljust(20) #-> "hello "
|
str.rjust( Integer ) → String If Integer is greater than the length of str, returns a new String of length Integer with str right justified and space padded; otherwise, returns str.
| rjust"hello".rjust(4) #-> "hello"
"hello".rjust(20) #-> " hello"
|
str.dump → String Produces a version of str with all nonprinting characters replaced by \nnn notation and all special characters escaped.
| |
str.crypt( String ) → String Applies a one-way cryptographic hash to str by invoking the standard library function crypt.
– The argument is the salt string, which should be two characters long, each character drawn from [a-zA-Z0-9./].
| |
~str → Fixnum or nil Equivalent to $_ =~ str
| |
indexOf str.index( String [, Offset ] ) → Fixnum or nil
str.index( Fixnum [, Offset ] ) → Fixnum or nil
str.index( Regexp [, Offset ] ) → Fixnum or nil Returns the index of the first occurrence of the given substring, character, or pattern in str.
Returns nil if not found.
If the second parameter is present, it specifies the position in the string to begin the search.
| index"Ruby".index("Ru") #-> 0
"Ruby".index("r") #-> nil
"Ruby".index(117) #-> 1
"Ruby".index("b") #-> 2
"Ruby".index(/.$/, 3) #-> 3
"Ruby".index(/.$/, 4) #-> nil
|
str.rindex( String [, Fixnum ] ) → Fixnum or nil
str.rindex( Fixnum [, Fixnum ] ) → Fixnum or nil
str.rindex( Regexp [, Fixnum ] ) → Fixnum or nil Returns the index of the last occurrence of the given substring, character, or pattern in str.
– Returns nil if not found.
– If the second parameter is present, it specifies the position in the string to end the search characters beyond this point will not be considered.
| rindex"hello".rindex('e') #-> 1
"hello".rindex('l') #-> 3
"hello".rindex('a') #-> nil
"hello".rindex(101) #-> 1
"hello".rindex(/[aeiou]/, -2) #-> 1
|
string to array str.split( pattern=$;, [ limit ] ) → Array Divides str into substrings based on a delimiter, returning an array of these substrings.
– If pattern is a String, then its contents are used as the delimiter when splitting str.
– If pattern is a single space, str is split on whitespace, with leading whitespace and runs of contiguous whitespace characters ignored.
– If pattern is a Regexp, str is divided where the pattern matches. Whenever the pattern matches a zero-length string, str is split into individual characters.
– If pattern is omitted, the value of $; is used. If $; is nil (which is the default), str is split on whitespace as if '[visible space]' were specified.
– If the limit parameter is omitted, trailing null fields are supressed.
– If limit is a positive number, at most that number of fields will be returned (if limit is 1, the entire string is returned as the only entry in an array).
– If negative, there is no limit to the number of fields returned, and trailing null fields are not supressed.
| split" now's the time".split #-> ["now's", "the", "time"]
" now's the time".split(' ') #-> ["now's", "the", "time"]
" now's the time".split(/ /) #-> ["", "now's", "", "the", "time"]
"1, 2.34,56, 7".split(/,\s*/) #-> ["1", "2.34", "56", "7"]
"hello".split(//) #-> ["h", "e", "l", "l", "o"]
"hello".split(//, 3) #-> ["h", "e", "llo"]
"hi mom".split(/\s*/) #-> ["h", "i", "m", "o", "m"]
"mellow yellow".split("ello") #-> ["m", "w y", "w"]
"1,2,,3,4,,".split(',') #-> ["1", "2", "", "3", "4"]
"1,2,,3,4,,".split(',', 4) #-> ["1", "2", "", "3,4,,"]
"1,2,,3,4,,".split(',', -4) #-> ["1", "2", "", "3", "4", "", ""]
|
.strip str.strip Returns a copy of str with leading and trailing whitespace removed. str.strip! → str or nil Removes leading and trailing whitespace from str. Returns nil if str was not altered.
| strip" hello ".strip #-> "hello"
"\tgoodbye\r\n".strip #-> "goodbye"
" first second third \n ".strip #-> "first second third"
|
str.reverse → String
str.reverse! → str Returns a new string with the characters from str in reverse order.
"reverse!" reverses str in place.
| reverseputs "abc".reverse #-> cba
reverse!s = "abc"
s.reverse!
puts s
|
integer, string to integer str.to_i → Integer Returns the result of interpreting leading characters in str as a decimal integer.
Extraneous characters past the end of a valid number are ignored.
If there is not a valid number at the start of str, 0 is returned.
The method never raises an exception.
| to_i"12345".to_i #-> 12345
"99 red balloons".to_i #-> 99
"0x0a".to_i #-> 0
"hello".to_i #-> 0
|
str.chomp( String=$/ ) → String Returns a new String with the given record separator removed from the end of str (if present). str.chomp!( String=$/ ) → str or nil Modifies str in place as described for String.chomp, returning str, or nil if no modifications were made.
| chomp"hello".chomp #-> "hello"
"hello\n".chomp #-> "hello"
"hello \n there".chomp #-> "hello \n there"
"hello".chomp("llo") #-> "he"
|
str.chop → String Returns a new String with the last character removed.
If the string ends with \r\n, both characters are removed.
Applying chop to an empty string returns an empty string.
String.chomp is often a safer alternative, as it leaves the string unchanged if it doesn't end in a record separator. str.chop! → str or nil Processes str as for String.chop, returning str, or nil if str is the empty string.
| chop"string\r\n".chop #-> "string"
"string\n\r".chop #-> "string\n"
"string\n".chop #-> "string"
"string".chop #-> "strin"
"x".chop.chop #-> ""
chop!s = "string" #-> string
s.chop! #-> strin
s #-> strin
t = ""
t.chop! #-> nil
|
str.count( [ String ]+ ) → Fixnum Each String parameter defines a set of characters to count.
The intersection of these sets defines the characters to count in str.
Any String that starts with a caret (^) is negated.
The sequence c1-c2 means all characters between c1 and c2.
| counta = "hello world"
a.count("lo") #-> 5 counts [lo]: he(l)(l)(o) w(o)r(l)d
a.count("lo", "o") #-> 2 counts intersection [o]: hell(o) w(o)rld
a.count("we", "w", "e") #-> 0 nothing to count, intersection in null
a.count("rrr", "reee", "r") #-> 1 counts intersection [r]: hello wo(r)ld
a.count("hello", "^l") #-> 4 counts intersection [heo]: (h)(e)ll(o) w(o)rld
a.count("ej-m") #-> 4 counts [ejklm]: h(e)(l)(l)o wor(l)d
|
delete string, str delete, string delete str.delete( [ String ]+ ) → String Returns a copy of str with all characters in the intersection of its arguments deleted.
Uses the same rules for building the set of characters as String.count str.delete!( [ String ]+ ) → str or nil Performs a delete operation in place, returning str, or nil if str was not modified.
| delete"hello".delete("l","lo") #-> "heo"
"hello".delete("lo") #-> "he"
"hello".delete("aeioul", "^l") #-> "hll"
"hello".delete("ej-m") #-> "ho"
"wer'3'33".delete("'") #-> 'wer333'
|
each line, each string, eachline, string each str.each( String=$/ ) {| substr | block } → str
str.each_line( String=$/ ) {| substr | block } → str (Synonym)Splits str using the supplied parameter as the record separator ($/ by default), passing each substring in turn to the supplied block.
– If a zero-length record separator is supplied, the string is split on \n characters, except that multiple successive newlines are appended together.
| eachprint "Example one\n"
"hello\nworld".each {|s| p s}
print "Example two\n"
"hello\nworld".each('l') {|s| p s}
print "Example three\n"
"hello\n\n\nworld".each(") {|s| p s}
produces:
Example one
"hello\n"
"world"
Example two
"hel"
"l"
"o\nworl"
"d"
Example three
"hello\n\n\n"
"world"
|
each byte str.each_byte {| Fixnum | block } → strPasses each byte in str to the given block.
| each_byte"hello".each_byte {|c| print c, ' ' }
produces:
104 101 108 108 111
|
'', "" str.empty? → true or false Returns true if str has a length of zero.
| empty?"hello".empty? #-> false
"".empty? #-> true
|
str.sub( pattern, replacement ) → String
str.sub( pattern ) {| match | block } → String Returns a copy of str with the first occurrence of pattern replaced with either replacement or the value of the block.
– If the string form of the method is used, special variables such as $& will not be useful, as substitution into the string occurs before the pattern match starts.
However, the sequences \1, \2 may be used.
– In the block form, the current match is passed in as a parameter, and variables such as $1, $2, $`, $&, and $' will be set appropriately. The value returned by the block will be substituted for the match on each call. str.sub!( pattern, replacement ) → str or nil
str.sub!( pattern ) {| match | block } → str or nil Performs the substitutions of String.sub in place, returning str, or nil if no substitutions were performed.
| sub"hello".sub(/[aeiou]/, '*') #-> "h*llo"
"hello".sub(/([aeiou])/, '<\1>') #-> "h<e>llo"
"hello".sub('.') {|s| s[0].to_s + ' ' } #-> "104 ello"
|
str.gsub( pattern, replacement ) → String
str.gsub( pattern ) {| match | block } → String Returns a copy of str with all occurrences of pattern replaced with either replacement or the value of the block.
– If a string is used as the replacement, special variables from the match (such as $& and $1) cannot be substituted into it, as substitution into the string occurs before the pattern match starts. However, the sequences \1, \2, and so on may be used to interpolate successive groups in the match.
– In the block form, the current match is passed in as a parameter, and variables such as $1, $2, $`, $&, and $' will be set appropriately.
– The value returned by the block will be substituted for the match on each call.
– The result inherits any tainting in the original string or any supplied replacement string. str.gsub!( pattern, replacement ) → str or nil
str.gsub!( pattern ) {| match | block } → str or nil Performs the substitutions of String.gsub in place, returning str, or nil if no substitutions were performed.
| gsub"hello".gsub(/[aeiou]/, '*') #-> "h*ll*"
"hello".gsub(/([aeiou])/, '<\1>') #-> "h<e>ll<o>"
"hello".gsub('.') {|s| s[0].to_s + ' '} #-> "104 101 108 108 111 "
|
/hex str.hex → Integer Treats leading characters from str as a string of hexadecimal digits (with an optional sign and an optional 0x) and returns the corresponding number.
– Zero is returned on error.
| hex"0x0a".hex #-> 10
"-1234".hex #-> -4660
"0".hex #-> 0
"wombat".hex #-> 0
|
str.oct → Integer Treats leading characters of str as a string of octal digits (with an optional sign) and returns the corresponding number.
– Returns 0 if the conversion fails.
| oct"123".oct #-> 83
"-377".oct #-> -255
"bad".oct #-> 0
"0377bad".oct #-> 255
|
str iclude, string include str.include? String → true or false
str.include? Fixnum → true or false Returns true if str contains the given string or character.
| include?"hello".include? "lo" #-> true
"hello".include? "ol" #-> false
"hello".include? ?h #-> true
|
str.intern → Symbol Returns the Symbol corresponding to str, creating the symbol if it did not previously exist.
| intern"Koala".intern #-> :Koala
|
str.length → Integer
str.size → Integer (Synonym) Returns the length of str.
| |
str.replace( String ) → str Replaces the contents and taintedness of str with the corresponding values in String.
| replaces = "hello" #-> "hello"
s.replace "world" #-> "world"
|
.scan str.scan( pattern ) → Array
str.scan( pattern ) {| match, ...| block } → str Both forms iterate through str, matching the pattern (which may be a Regexp or a String). For each match, a result is generated and either added to the result array or passed to the block.
– If the pattern contains no groups, each individual result consists of the matched string, $&.
– If the pattern contains groups, each individual result is itself an array containing one entry per group.
| scana = "cruel world"
a.scan(/\w+/) #-> ["cruel", "world"]
a.scan(/.../) #-> ["cru", "el ", "wor"]
a.scan(/(...)/) #-> [["cru"], ["el "], ["wor"]]
a.scan(/(..)(..)/) #-> [["cr", "ue"], ["l ", "wo"]]
And the block form:
a.scan(/\w+/) {|w| print "<<#{w}>> " }
print "\n"
a.scan(/(.)(.)/) {|a,b| print b, a }
print "\n"
produces:
<<cruel>> <<world>>
rceu lowlr
|
str.squeeze( [ String ]* ) → NewString Builds a set of characters from the String parameter(s) using the procedure described for String.count.
– Returns a new string where runs of the same character that occur in this set are replaced by a single character.
– If no arguments are given, all runs of identical characters are replaced by a single character. str.squeeze!( [ String ]* ) → str or nil Squeezes str in place, returning either str, or nil if no changes were made.
| squeeze"yellow moon".squeeze #-> "yelow mon"
" now is the".squeeze(" ") #-> " now is the"
"putters shoot balls".squeeze("m-z") #-> "puters shot balls"
|
str.succ → String
str.next → String (Synonym) Returns the successor to str.
– The successor is calculated by incrementing characters starting from the rightmost alphanumeric (or the rightmost character if there are no alphanumerics) in the string. Incrementing a digit always results in another digit, and incrementing a letter results in another letter of the same case. Incrementing nonalphanumerics uses the underlying character set's collating sequence.
– If the increment generates a "carry," the character to the left of it is incremented. This process repeats until there is no carry, adding an additional character if necessary. str.succ! → str
str.next! → str (Synonym) Equivalent to String.succ , but modifies the receiver in place.
| succ"abcd".succ #-> "abce"
"THX1138".succ #-> "THX1139"
"<<koala>>".succ #-> "<<koalb>>"
"1999zzz".succ #-> "2000aaa"
"ZZZ9999".succ #-> "AAAA0000"
"***".succ #-> "**+"
|
str.sum( Fixnum=16 ) → Integer Returns a basic n-bit checksum of the characters in str, where n is the optional parameter, defaulting to 16. The result is simply the sum of the binary value of each character in str modulo 2^n - 1.
– This is not a particularly good checksum.
| |
swap case str.swapcase → String Returns a copy of str with uppercase alphabetic characters converted to lowercase and lowercase characters converted to uppercase. str.swapcase! → str or nil Equivalent to String.swapcase, but modifies the receiver in place, returning str, or nil if no changes were made.
| swapcase"Hello".swapcase #-> "hELLO"
"cYbEr_PuNk11".swapcase #-> "CyBeR_pUnK11"
|
to Float str.to_f → Float Returns the result of interpreting leading characters in str as a floating point number.
– Extraneous characters past the end of a valid number are ignored.
– If there is not a valid number at the start of str, 0.0 is returned.
– The method never raises an exception.
| to_f"123.45e1".to_f #-> 1234.5
"45.67 degrees".to_f #-> 45.67
"thx1138".to_f #-> 0.0
|
str.to_s → str Returns the receiver.
| |
str.to_str → str Synonym for String.to_s.
to_str is used by methods such as String#concat to convert their arguments to a string.
– Unlike to_s, which is supported by almost all classes, to_str is normally implemented only by those classes that act like strings. Of the built-in classes, only Exception and String implement to_str.
| |
.tr, transliteration str.tr( fromString, toString ) → String Returns a copy of str with the characters in fromString replaced by the corresponding characters in toString.
– If toString is shorter than fromString, it is padded with its last character.
– Both strings may use the c1-c2 notation to denote ranges of characters, and fromString may start with a ^, which denotes all characters except those listed. str.tr!( fromString, toString ) → str or nil Translates str in place, using the same rules as String.tr.
– Returns str, or nil if no changes were made.
| tr"hello".tr('aeiou', '*') #-> "h*ll*"
"hello".tr('^aeiou', '*') #-> "*e**o"
"hello".tr('el', 'ip') #-> "hippo"
"hello".tr('a-y', 'b-z') #-> "ifmmp"
|
str.tr_s( fromString, toString ) → String Processes a copy of str as described under String.tr, then removes duplicate characters in regions that were affected by the translation. str.tr_s!( fromString, toString ) → str or nil Performs String.tr_s processing on str in place, returning str, or nil if no changes were made.
| tr_s"hello".tr_s('l', 'r') #-> "hero"
"hello".tr_s('el', '*') #-> "h*o"
"hello".tr_s('el', 'hx') #-> "hhxo"
|
str.unpack( format ) → Array Decodes str (which may contain binary data) according to the format string, returning an array of each value extracted.
– The format string consists of a sequence of single-character directives.
– Each directive may be followed by a number, indicating the number of times to repeat with this directive. An asterisk ("*") will use up all remaining elements.
– The directives sSiIlL may each be followed by an underscore ("_") to use the underlying platform's native size for the specified type; otherwise, it uses a platform-independent consistent size. Spaces are ignored in the format string.
– See also Array.pack.
A String with trailing nulls and spaces removed. → String
a String. → String
B Extract bits from each character (msb first) → String
b Extract bits from each character (lsb first) → String
C Extract a character as an unsigned integer → Fixnum
c Extract a character as an integer → Fixnum
d Treat sizeof(double) characters as a native double → Float
E Treat sizeof(double) characters as a double in little-endian byte order → Float
e Treat sizeof(float) characters as a float in little-endian byte order → Float
f Treat sizeof(float) characters as a native float → Float
G Treat sizeof(double) characters as a double in network byte order → Float
g Treat sizeof(float) characters as a float in network byte order → Float
H Extract hex nibbles from each character (most significant first) → String
h Extract hex nibbles from each character (least significant first) → String
I Treat sizeof(int)[1] successive characters as an unsigned native integer → Integer
i Treat sizeof(int)[1] successive characters as a signed native integer → Integer
L Treat four[1] successive characters as an unsigned native long integer → Integer
l Treat four[1] successive characters as a signed native long integer → Integer
M Extract a quoted-printable string → String
m Extract a base64 encoded string → String
N Treat four characters as an unsigned long in network byte order → Fixnum
n Treat two characters as an unsigned short in network byte order → Fixnum
P Treat sizeof(char *) characters as a pointer, and return len characters from the referenced location → String
p Treat sizeof(char *) characters as a pointer to a null-terminated string → String
S Treat two[1] successive characters as an unsigned short in native byte order → Fixnum
s Treat two[1] successive characters as a signed short in native byte order → Fixnum
U Extract UTF-8 characters as unsigned integers → Integer
u Extract a UU-encoded string → String
V Treat four characters as an unsigned long in little-endian byte order → Fixnum
v Treat two characters as an unsigned short in little-endian byte order → Fixnum
X Skip backward one character
x Skip forward one character
Z String with trailing nulls removed → String
@ Skip to the offset given by the length argument
[1] – May be modified by appending "_" to the directive.
| unpack"abc \0\0abc \0\0".unpack('A6Z6') #-> ["abc", "abc "]
"abc \0\0".unpack('a3a3') #-> ["abc", " \000\000"]
"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('xax2X2X1X2a') #-> ["h", "e", "l", "l", "o"]
\nnn, \xxx Cyrillic unpack"\320\240\320\270".to_a.pack('A*') --> 'Ри'
|
str.upto( String ) {| s | block } → strIterates through successive values, starting at str and ending at String inclusive, passing each value in turn to the block.
– The String.succ method is used to generate each value.
| upto"a8".upto("b6") {|s| print s, ' ' }
for s in "a8".."b6"
print s, ' '
end
produces:
a8 a9 b0 b1 b2 b3 b4 b5 b6
a8 a9 b0 b1 b2 b3 b4 b5 b6
|
| |
time.now Time.new → Time
Time.now → Time (synonym) Returns a Time object initialized to the current system time.
Note: The object created will be created using the resolution available on your system clock, and so may include fractional seconds.
| newa = Time.new #-> Sun Jun 09 00:19:20 CDT 2002
b = Time.new #-> Sun Jun 09 00:19:20 CDT 2002
a == b #-> false
"%.6f" % a.to_f #-> "1023599960.526217"
"%.6f" % b.to_f #-> "1023599960.526838"
|
time at, time_at Time.at( Time ) → Time
Time.at( seconds [, microseconds ] ) → Time Creates a new time object with the value given by Time, or the given number of seconds (and optional microseconds) from epoch.
| atTime.at(0) #-> Thu Jan 01 02:00:00 +0200 1970
Time.at(946702800) #-> Sat Jan 01 07:00:00 +0200 2000
|
Time.gm( year [, month, day, hour, min, sec, usec] ) → Time
Time.gm( sec, min, hour, day, month, year, wday, yday, isdst, tz ) → Time
#synonym
Time.utc( year [, month, day, hour, min, sec, usec] ) → Time
Time.utc( sec, min, hour, day, month, year, wday, yday, isdst, tz ) → Time Creates a time based on given values, interpreted as UTC (GMT).
The year must be specified.
Other values default to the minimum value for that field (and may be nil or omitted).
Months may be specified by numbers from 1 to 12, or by the three-letter English month names.
Hours are specified on a 24-hour clock (0..23).
Raises an ArgumentError if any values are out of range.
Will also accept ten arguments in the order output by Time.to_a.
| gmTime.gm(2000,"jan",1,20,15,1) #-> Sat Jan 01 20:15:01 UTC 2000
|
localtime, timelocal Time.local( year [, month, day, hour, min, sec, usec] ) → Time
Time.local( sec, min, hour, day, month, year, wday, yday, isdst, tz ) → Time
Time.mktime( year [, month, day, hour, min, sec, usec] ) → Time (synonym) Same as Time.gm, but interprets the values in the local time zone.
| localTime.local(2000,"jan",1,20,15,1) #-> Sat Jan 01 20:15:01 CST 2000
|
Process.times → StructTms
Time.times → StructTms (obsolete) Returns a Tms structure that contains user and system CPU times for this process.
| timest = Process.times
puts [ t.utime, t.stime ] #-> [0.375, 0.218]
|
time + Numeric → Time Addition. Adds some number of seconds (possibly fractional) to time and returns that value as a new time. time - Time → Float
time - Numeric → Time Difference. Returns a new time that represents the difference between two times, or subtracts the given number of seconds in Numeric from time. time <=> OtherTime → -1, 0, +1
time <=> Numeric → -1, 0, +1 Comparison. Compares time with OtherTime or with Numeric, which is the number of seconds (possibly fractional) since epoch.
| Additiont = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t + (60 * 60 * 24) #-> Mon Nov 26 23:50:41 CST 2001
Differencet = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t2 = t + 2592000 #-> Tue Dec 25 23:50:41 CST 2001
t2 - t #-> 2592000.0
t2 - 2592000 #-> Sun Nov 25 23:50:41 CST 2001
Comparisont = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t2 = t + 2592000 #-> Tue Dec 25 23:50:41 CST 2001
t <=> t2 #-> -1
t2 <=> t #-> 1
t <=> t #-> 0
|
time.asctime → String
time.ctime → String (Synonym) Returns a canonical string representation of time.
| asctimeTime.now.asctime #-> "Sun Nov 25 23:50:41 2001"
|
time.gmtime → time
time.utc → time (Synonym) Converts time to UTC (GMT), modifying the receiver. time.gmt? → true or false
time.utc? → true or false (Synonym) Returns true if time represents a time in UTC (GMT).
| gmtimet = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.gmt? #-> false
t.gmtime #-> Mon Nov 26 05:50:41 UTC 2001
t.gmt? #-> true
utct = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.utc? #-> false
t.utc #-> Mon Nov 26 05:50:41 UTC 2001
t.utc? #-> true
gmt?, utc?t = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.gmt? #-> false
t.utc? #-> false
t = Time.gm(2000,"jan",1,20,15,1) #-> Sat Jan 01 20:15:01 UTC 2000
t.gmt? #-> true
t.utc? #-> true
|
time.sec → Fixnum Returns the second of the minute (0..60) for time.
– Yes, seconds really can range from zero to 60. This allows the system to inject leap seconds every now and then to correct for the fact that years are not really a convenient number of hours long.
| sect = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.sec #-> 41
|
time.min → Fixnum Returns the minute of the hour (0..59) for time.
| mint = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.min #-> 50
|
time.hour → Fixnum Returns the hour of the day (0..23) for time.
| hourt = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.hour #-> 23
|
time.day → Fixnum
time.mday → Fixnum (Synonym) Returns the day of the month (1..n) for time.
| dayt = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.day #-> 25
|
day of week, week day, weekday time.wday → Fixnum Returns an integer representing the day of the week, 0..6, with Sunday == 0.
| wdayt = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.wday #-> 0
|
time.mon → Fixnum
time.month → Fixnum (Synonym) Returns the month of the year (1..12) for time.
| mont = Time.now #-> Sat Mar 31 16:26:44 +0300 2007
t.mon #-> 3
|
time.year → Fixnum Returns the year for time (including the century).
| yeart = Time.now #-> Sun Nov 25 23:50:42 CST 2001
t.year #-> 2001
|
day of the year, day year, year day time.yday → Fixnum Returns an integer representing the day of the year, 1..366.
| ydayt = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t.yday #-> 329
|
time.zone → String Returns the name of the time zone used for time.
| zonet = Time.gm(2000, "jan", 1, 20, 15, 1)
t.zone #-> "GMT"
t = Time.local(2000, "jan", 1, 20, 15, 1)
t.zone #-> "CST"
|
time.isdst → true or false Returns true if time occurs during Daylight Saving Time in its time zone.
| isdstt = Time.local(2000, 7, 1) #-> Sat Jul 01 00:00:00 CDT 2000
t.isdst #-> true
t2 = Time.local(2000, 1, 1) #-> Sat Jan 01 00:00:00 CST 2000
t2.isdst #-> false
|
time.localtime → time Converts time to local time (using the local time zone in effect for this process) modifying the receiver.
| localtimet = Time.gm(2000, "jan", 1, 20, 15, 1)
t.gmt? #-> true
t.localtime #-> Sat Jan 01 14:15:01 CST 2000
t.gmt? #-> false
|
date formatting, date output, date to string, print date time.strftime( String ) → String Formats time according to the directives in the given format string.
Any text not listed as a directive will be passed through to the output string. formatted Directives Format Meaning %a – The abbreviated weekday name ("Sun")
%A – The full weekday name ("Sunday")
%b – The abbreviated month name ("Jan")
%B – The full month name ("January")
%c – The preferred local date and time representation
%d – Day of the month (01..31)
%H – Hour of the day, 24-hour clock (00..23)
%I – Hour of the day, 12-hour clock (01..12)
%j – Day of the year (001..366)
%m – Month of the year (01..12)
%M – Minute of the hour (00..59)
%p – Meridian indicator ("AM" or "PM")
%S – Second of the minute (00..60)
%U – Week number of the current year, starting with the first Sunday as the first day of the first week (00..53)
%W – Week number of the current year, starting with the first Monday as the first day of the first week (00..53)
%w – Day of the week (Sunday is 0, 0..6)
%x – Preferred representation for the date alone, no time
%X – Preferred representation for the time alone, no date
%y – Year without a century (00..99)
%Y – Year with century (2011)
%Z – Time zone name
%% – Literal "%" character
| strftimet = Time.now
t.strftime("Printed on %m/%d/%Y") #-> "Printed on 11/25/2001"
t.strftime("at %I:%M%p") #-> "at 11:50PM"
|
time.to_a → Array Returns a ten-element Array of values for time: {[ sec, min, hour, day, month, year, wday, yday, isdst, zone ]}.
See the individual methods for an explanation of the valid ranges of each value.
The ten elements can be passed directly to Time.utc or Time.local to create a new Time.
| to_anow = Time.now #-> Sun Nov 25 23:50:41 CST 2001
t = now.to_a #-> [41, 50, 23, 25, 11, 2001, 0, 329, false, "CST"]
|
time.to_f → Float Returns the value of time as a floating point number of seconds since epoch.
| to_ft = Time.now
"%10.5f" % t.to_f #-> "1006753841.72788"
t.to_i #-> 1006753841
|
time.to_i → Integer
time.tv_sec → Integer (Synonym) Returns the value of time as an integer number of seconds since epoch.
| to_it = Time.now
"%10.5f" % t.to_f #-> "1006753841.76503"
t.to_i #-> 1006753841
|
time.usec → Integer
time.tv_usec → Integer (Synonym) Returns just the number of microseconds for time.
| usect = Time.now #-> Sun Nov 25 23:50:41 CST 2001
"%10.6f" % t.to_f #-> "1006753841.837830"
t.usec #-> 837830
|
time.to_s → String Returns a string representing time.
Equivalent to calling Time.strftime with a format string of "%a %b %d %H:%M:%S %Z %Y".
| to_sTime.now.to_s #-> "Sun Nov 25 23:50:41 CST 2001"
|
2616 Time.now.httpdate → String Returns a string which represents the time as rfc1123-date of HTTP-date defined by RFC 2616:
day-of-week, DD month-name CCYY hh:mm:ss GMT
- Result is always UTC (GMT)
| httpdateTime.now.httpdate #-> Tue, 08 Jan 2008 07:49:30 GMT
|
| |
//, case sensitivity, pattern, Regexp /pattern/
/pattern/options
%r{pattern}
%r{pattern}options
Regexp.new( 'pattern' [, options ] )
Regexp.new( pattern [, options [ lang ] ] ) → Regexp Constructs a new regular expression from pattern, which can be either a String or a Regexp (in which case that regexp's options are not propagated).
– If options is a Fixnum, it should be one or more of the constants or-ed together
Regexp::EXTENDED – Ignore spaces and newlines
Regexp::IGNORECASE – Matches are case insensitive
Regexp::POSIXLINE – Newlines treated as any other character
– Otherwise, if options is not nil, the regexp will be case insensitive.
– Regular expressions are objects of type Regexp
– The lang parameter enables multibyte support for the regexp:
'n', 'N' = none
'e', 'E' = EUC
's', 'S' = SJIS
'u', 'U' = UTF-8
| newr1 = Regexp.new('^a-z+:\\s+\w+') #-> /^a-z+:\s+\w+/
r2 = Regexp.new(r1, true) #-> /^a-z+:\s+\w+/i
r3 = Regexp.new(r2, Regexp::EXTENDED) #-> /^a-z+:\s+\w+/x
Regexp creatinga = Regexp.new('^\s*[az]') #-> /^\s*[az]/
b = /^\s*[az]/ #-> /^\s*[az]/
c = %r{^\s*[az]} #-> /^\s*[az]/
regexp escapeRegexp.escape('we$xcg^456\sdg\s') #-> 'we\$xcg\^456\\sdg\\s'
|
Options A regular expression may include one or more options that modify the way the pattern matches strings.
– If you're using literals to create the Regexp object, then the options comprise one or more characters placed immediately after the terminator.
– If you're using Regexp.new, the options are constants used as the second parameter of the constructor. /i, case sensitivity /.../i Case Insensitive.
The pattern match will ignore the case of letters in the pattern and string.
Matches are also case-insensitive if the global variable $= is set. /o /.../o Substitute Once.
Any #{...} substitutions in a particular regular expression literal will be performed just once, the first time it is evaluated. Otherwise, the substitutions will be performed every time the literal generates a Regexp object./m /.../m Multiline Mode.
Normally, "." matches any character except a newline. With the /m option, "." matches any character. /x /.../x Extended Mode.
Complex regular expressions can be difficult to read. The 'x' option allows you to insert spaces, newlines, and comments in the pattern to make it more readable.
| |
Match operators Once you have a regular expression object, you can match it against a string using Regexp.match(string) or the match operators =~ (positive match) and !~ (negative match). The match operators are defined for both String and Regexp objects. At least one operand of the match operator must be a regular expression.
– The match operators return the character position at which the match occurred.
| String matchingname = "Fats Waller"
name =~ /a/ #-> 1
name != /z/ #-> true
/a/ =~ name #-> 1
/a/.match(name) #-> MatchData object
/z/.match(name) #-> nil
m = /l+(.*)/.match(name)
m.to_s #-> ller (whole match)
m[1] #-> er (same as $1 when using =~)
|
$2, $3, $4, $5, $6, $7, $8 Regexp variables $& – receives the part of the string that was matched by the pattern (matched part)
$+ – contents of the highest-numbered group matched in the last successful pattern match. This variable is local to the current scope.
$` – receives the part of the string that preceded the match
$' – receives the string after the match
$= – If set to any value apart from nil or false, all pattern matches will be case insensitive, string comparisons will ignore case, and string hash values will be case insensitive.
– The match also sets the thread-global variables $~ and $1 through $9. The variable $~ is a MatchData object that holds everything you may want to know about the match. $1, and so on, hold the values of parts of the match. Patterns – Within a pattern, all characters except: .|()[]{}+\^$*? match themselves. If you want to match one of these special characters literally, precede it with a backslash.
– Regular expression may contain #{...} expression substitutions.
| Regexp variablesdef show_regexp(a, re)
if a =~ re
"#{$`}<<#{$&}>>#{$'}"
else
"no match"
end
end
show_regexp('very interesting', /t/) #-> very in<<t>>eresting
show_regexp('Fats Waller', /a/) #-> F<<a>>ts Waller
show_regexp('Fats Waller', /ll/) #-> Fats Wa<<ll>>er
show_regexp('Fats Waller', /z/) #-> no match
$+"cat" =~ /(c|a)(t|z)/ # $+ will be set to "t"
|
end of line, end of string Anchors – The patterns ^ and $ match the beginning and end of a line, respectively.
– The sequence \A matches the beginning of a string
– \z and \Z match the end of a string. (Actually, \Z matches the end of a string unless the string ends with a \n, in which case it matches just before the \n.)
– Similarly, the patterns \b and \B match word boundaries and nonword boundaries, respectively.Word characters are letters, numbers, and underscores.
| Anchorsshow_regexp("this is\nthe time", /^the/) #-> this is\n<<the>> time
show_regexp("this is\nthe time", /is$/) #-> this <<is>>\nthe time
show_regexp("this is\nthe time", /\Athis/) #-> <<this>> is\nthe time
show_regexp("this is\nthe time", /\Athe/) #-> no match
show_regexp("this is\nthe time", /\bis/) #-> this <<is>>\nthe time
show_regexp("this is\nthe time", /\Bis/) #-> th<<is>> is\nthe time
|
Alternation re1 | re2 – Matches either the regular expression that precedes it or the regular expression that follows it.
– There’s a trap for the unwary here, as | has a very low precedence.
| Alternation samplea = "red ball blue sky"
show_regexp(a, /d|e/) #-> r<<e>>d ball blue sky
show_regexp(a, /al|lu/) #-> red b<<al>>l blue sky
show_regexp(a, /red ball|angry sky/) #-> <<red ball>> blue sky
|
\1, \2, \3, $1, $2, $3 Grouping (...) – You can use parentheses to group terms within a regular expression. Everything within the group is treated as a single regular expression.
– Parentheses also collect the results of pattern matching. Ruby counts opening parentheses, and for each stores the result of the partial match between it and the corresponding closing parenthesis. You can use this partial match both within the rest of the pattern and in your Ruby program. Within the pattern, the sequence \1 refers to the match of the first group, \2 the second group, and so on.
– Outside the pattern, the special variables $1, $2, and so on, serve the same purpose. Composition You can combine regexpes together with the string interpolation mechanism. The included regexp will be surrounded by an uncapturing group.
| Groupingshow_regexp('banana', /an*/) #-> b<<an>>ana
show_regexp('banana', /(an)*/) #-> <<>>banana
show_regexp('banana', /(an)+/) #-> b<<anan>>a
a = 'red ball blue sky'
show_regexp(a, /blue|red/) #-> <<red>> ball blue sky
show_regexp(a, /(blue|red) \w+/) #-> <<red ball>> blue sky
show_regexp(a, /(red|blue) \w+/) #-> <<red ball>> blue sky
show_regexp(a, /red|blue \w+/) #-> <<red>> ball blue sky
show_regexp(a, /red (ball|angry) sky/) #-> no match
a = 'the red angry sky'
show_regexp(a, /red (ball|angry) sky/) #-> the <<red angry sky>>
Groupingshow_regexp('banana', /an*/) #-> b<<an>>ana
show_regexp('banana', /(an)*/) #-> <<>>banana
show_regexp('banana', /(an)+/) #-> b<<anan>>a
a = 'red ball blue sky'
show_regexp(a, /blue|red/) #-> <<red>> ball blue sky
show_regexp(a, /(blue|red) \w+/) #-> <<red ball>> blue sky
show_regexp(a, /(red|blue) \w+/) #-> <<red ball>> blue sky
show_regexp(a, /red|blue \w+/) #-> <<red>> ball blue sky
show_regexp(a, /red (ball|angry) sky/) #-> no match
a = 'the red angry sky'
show_regexp(a, /red (ball|angry) sky/) #-> the <<red angry sky>>
$1, $2 special variables"12:50am" =~ /(\d\d):(\d\d)(..)/ #-> 0
"Hour is #$1, minute #$2" #-> "Hour is 12, minute 50"
"12:50am" =~ /((\d\d):(\d\d))(..)/ #-> 0
"Time is #$1" #-> "Time is 12:50"
"Hour is #$2, minute #$3" #-> "Hour is 12, minute 50"
"AM/PM is #$4" #-> "AM/PM is am"
using \1-\9show_regexp('He said "Hello"', /(\w)\1/) #-> He said "He<<ll>>o"
show_regexp('Mississippi', /(\w+)\1/) #-> M<<ississ>>ippi
show_regexp('He said "Hello"', /(["']).*?\1/) #-> He said <<"Hello">>
show_regexp("He said 'Hello'", /(["']).*?\1/) #-> He said <<'Hello'>>
\1 get $1 in one linetext = 'some text 95% some text'
text[/\((\d+%)\)/] && $1 # → 95
|
Extensions In common with Perl and Python, Ruby regular expressions offer some extensions over traditional Unix regular expressions.
– All the extensions are entered between the characters (? and ).
– The parentheses that bracket these extensions are groups, but they do not generate backreferences: they do not set the values of \1 and $1 etc.
| |
?# (?# comment) Inserts a comment into the pattern. The content is ignored during pattern matching.
| |
?: (?:re) Makes re into a group without generating backreferences.
This is often useful when you need to group a set of constructs but don't want the group to set the value of $1 or whatever.
| In the example that follows, both patterns match a date with either colons or spaces between the month, day, and year. The first form stores the separator character in $2 and $4, while the second pattern doesn't store the separator in an externaldate = "12/25/01"
date =~ %r{(\d+)(/|:)(\d+)(/|:)(\d+)}
[$1,$2,$3,$4,$5] #-> ["12", "/", "25", "/", "01"]
date =~ %r{(\d+)(?:/|:)(\d+)(?:/|:)(\d+)}
[$1,$2,$3] #-> ["12", "25", "01"]
|
?= (?=re) Matches re at this point, but does not consume it (also known charmingly as "zero-width positive lookahead").
This lets you look forward for the context of a match without affecting $&.
| In this example, the scan method matches words followed by a comma, but the commas are not included in the result.str = "red, white, and blue"
str.scan(/[a-z]+(?=,)/) #-> ["red", "white"]
|
?! (?!re) Matches if re does not match at this point.
Does not consume the match (zero-width negative lookahead).
| For example, this matches any word that contains the letters "hot" that aren't followed by "dog", returning the end of the word in $1"hot hotdog hotlight" =~ /hot(?!dog)(\w+)/ #-> 11
$1 #-> light
|
?> (?>re) Nests an independent regular expression within the first regular expression.
This expression is anchored at the current match position. If it consumes characters, these will no longer be available to the higher-level regular expression. This construct therefore inhibits backtracking, which can be a performance enhancement.
| For example, the pattern /a.*b.*a/ takes exponential time when matched against a string containing an "a" followed by a number of "b"s, but with no trailing "a." However, this can be avoided by using a nested regular expression /a(?>.*b).*a/. In this form, the nested expression consumes all the the input string up to the last possible "b" character. When the check for a trailing "a" then fails, there is no need to backtrack, and the pattern match fails promptly.require "benchmark"
include Benchmark
str = "a" + ("b" * 5000)
bm(8) do |test|
test.report("Normal:") { str =~ /a.*b.*a/ }
test.report("Nested:") { str =~ /a(?>.*b).*a/ }
end
produces:
user system total real
Normal: 0.410000 0.000000 0.410000 (0.414915)
Nested: 0.000000 0.000000 0.000000 (0.001190)
|
?i, ?m, ?x (?imx) Turns on the corresponding "i", "m" or "x" option. If used inside a group, the effect is limited to that group. ?-i, ?-m, ?-x (?-imx) Turns off the "i", "m", or "x" option. ?i:, ?m:, ?x: (?imx:re) Turns on the "i", "m", or "x" option for re. ?-i:, ?-m:, ?-x: (?-imx:re) Turns off the "i", "m", or "x" option for re.
| |
.sub(/pattern/, '*')
.gsub(/pattern/, '*')
.sub(/pattern/) {|match| ... } The methods String.sub and String.gsub look for a portion of a string matching their first argument and replace it with their second argument. String.sub performs one replacement, and String.gsub replaces every occurrence of the match. Both routines return a new copy of the String containing the substitutions. Mutator versions String.sub! and String.gsub! modify the original string.
– The second argument to both functions can be either a String or a block. If a block is used, it is passed the matching substring, and the block’s value is substituted into the original string. \ Backslash sequences – Earlier we noted that the sequences \1, \2, and so on, are available in the pattern, standing for the nth group matched so far. The same sequences are available in the second argument of sub and gsub.
– Additional backslash sequences work in substitution strings:
\& (last match)
\+ (last matched group)
\` (string prior to match)
\' (string after match)
\\ (a literal backslash).
| sub and gsub samplesa = "the quick brown fox"
a.sub(/[aeiou]/, '*') #-> "th* quick brown fox"
a.gsub(/[aeiou]/, '*') #-> "th* q**ck br*wn f*x"
a.sub(/\s\S+/, '') #-> "the brown fox"
a.gsub(/\s\S+/, '') #-> "the"
sub & gsub with blocka = "the quick brown fox"
a.sub(/^./) {|match| match.upcase } #-> "The quick brown fox"
a.gsub(/[aeiou]/) {|vowel| vowel.upcase } #-> "thE qUIck brOwn fOx"
sub & gsub with \"fred:smith".sub(/(\w+):(\w+)/, '\2, \1') #-> "smith, fred"
"nercpyitno".gsub(/(.)(.)/, '\2\1') #-> "encryption"
gsub converting \ to \\str = 'a\b\c'
str.gsub(/\\/, '\\\\\\\\') #-> "a\\b\\c"
str.gsub(/\\/, '\&\&') #-> "a\\b\\c"
str.gsub(/\\/) { '\\\\' } #-> "a\\b\\c"
|
.match – The method Regexp.match matches a regular expression against a string. If unsuccessful, the method returns nil. On success, it returns an instance of class MatchData. And that MatchData object gives you access to all available information about the match. All that good stuff that you can get from the $-variables is bundled in a handy little object.
– Because the match data is stored in its own object, you can keep the results of two or more pattern matches available at the same time, something you can’t do using the $-variables.
– So how do the $-variables fit in? Well, after every pattern match, Ruby stores a reference to the result (nil or a MatchData object) in a thread-local variable (accessible using $~). All the other regular expression variables are then derived from this object. Although we can’t really think of a use for the following code, it demonstrates that all the other MatchData-related $-variables are indeed slaved off the value in $~.
| MatchData, special variablesre = /(\d+):(\d+)/ # match a time hh:mm
md = re.match("Time: 12:34am")
md.class #-> MatchData
md[0] #-> "12:34" (same as $&)
md[1] #-> "12" (same as $1)
md[2] #-> "34" (same as $2)
md.pre_match #-> "Time: " (same as $`)
md.post_match #-> "am" (same as $')
match Two pattern matches available at the same timere = /(\d+):(\d+)/ # match a time hh:mm
md1 = re.match("Time: 12:34am")
md2 = re.match("Time: 10:30pm")
md1[1, 2] #-->["12", "34"]
md2[1, 2] #-->["10", "30"]
match $~re = /(\d+):(\d+)/
md1 = re.match("Time: 12:34am")
md2 = re.match("Time: 10:30pm")
[ $1, $2 ] # last successful match #-->["10", "30"]
$~ = md1
[ $1, $2 ] # previous successful match #-->["12", "34"]
|
Character Classes – A character class is a set of characters between brackets: [characters] matches any single character between the brackets. [aeiou] will match a vowel, [,.:;!?] matches punctuation, and so on. The significance of the special regular expression characters .|()[{+^$*? — is turned off inside the brackets. However, normal string substitution still occurs, so (for example) \b represents a backspace character and \n a newline.
– Within the brackets, the sequence c1-c2 represents all the characters between c1 and c2, inclusive.
– If you want to include the literal characters ] and - within a character class, they must appear at the start. Put a ^ immediately after the opening bracket to negate a character class: [^a-z] matches any character that isn't a lowercase alphabetic.
– Finally, a period . appearing outside brackets represents any character except a newline (though in multiline mode it matches a newline, too).
– The sequences \d, \D, \s, \S, \w, and \W are abbreviations for groups of charactersCharacter class abbreviations \d = [0-9] – Digit character
\D = [^0-9] – Nondigit
\s = [\s\t\r\n\f] – Whitespace character
\S = [^\s\t\r\n\f] – Nonwhitespace character
\w = [A-Za-z0-9_] – Word character
\W = [^A-Za-z0-9_] – Nonword character [: POSIX Character Classes [:alnum:] – Alphanumeric
[:alpha:] – Uppercase or lowercase letter
[:blank:] – Blank and tab
[:cntrl:] – Control characters (at least 0x00-0x1f, 0x7f)
[:digit:] – Digit
[:graph:] – Printable character excluding space
[:lower:] – Lowercase letter
[:print:] – Any printable character (including space)
[:punct:] – Printable character excluding space and alphanumeric
[:space:] – Whitespace (same as \s)
[:upper:] – Uppercase letter
[:xdigit:] – Hex digit (0-9, a-f, A-F)
| Character Classesshow_regexp('Price $12.', /[aeiou]/) #-> Pr<<i>>ce $12.
show_regexp('Price $12.', /[\s]/) #-> Price<< >>$12.
show_regexp('Price $12.', /[[:digit:]]/) #-> Price $<<1>>2.
show_regexp('Price $12.', /[[:space:]]/) #-> Price<< >>$12.
show_regexp('Price $12.', /[[:punct:]aeiou]/) #-> Pr<<i>>ce $12.
a = 'see [Design Patternspage 123]'
show_regexp(a, /[A-F]/) #-> see [<<D>>esign Patternspage 123]
show_regexp(a, /[A-Fa-f]/) #-> s<<e>>e [Design Patternspage 123]
show_regexp(a, /[0-9]/) #-> see [Design Patternspage <<1>>23]
show_regexp(a, /[0-9][0-9]/) #-> see [Design Patternspage <<12>>3]
a = 'see [Design Pattern-spage 123]'
show_regexp(a, /[]]/) #-> see [Design Pattern-spage 123<<]>>
show_regexp(a, /[-]/) #-> see [Design Patterns<<->>page 123]
show_regexp(a, /[^a-z]/) #-> see<< >>[Design Pattern-spage 123]
show_regexp(a, /[^a-z\s]/) #-> see <<[>>Design Pattern-spage 123]
a = 'It costs $12.'
show_regexp(a, /c.s/) #-> It <<cos>>ts $12.
show_regexp(a, /./) #-> <<I>>t costs $12.
show_regexp(a, /\./) #-> It costs $12<<.>>
|
regexp, regular expressions, var in regexp, var regexp, variable in regexp, variables How to use Ruby variables in regular expressions If you do not know the pattern that you are trying to match ahead of time (e.g. it is some form of user input), you can construct a regex from a string:
str = "this string has ruby in it"
re = "ruby"
str =~ /#{Regexp.escape(re)}/ # => 16
You can also combine components to create a new pattern:
a = 'ruby'
b = 'on rails'
str = "this string has ruby on rails in it"
str.match(/#{a} #{b}/) # => true
If you are looking for a way to create patterns from combinations of common elements, and the elements are not derived from input, it is just as easy to combine Regexp objects:
a = /ruby/
b = /on rails/
str = "this string has ruby on rails in it"
str.match(/#{a} #{b}/) # => true
| examplestr = "this string has ruby in it"
re = "ruby"
str =~ /#{Regexp.escape(re)}/ # => 16
examplea = 'ruby'
b = 'on rails'
str = "this string has ruby on rails in it"
str.match(/#{a} #{b}/) # => true
examplea = /ruby/
b = /on rails/
str = "this string has ruby on rails in it"
str.match(/#{a} #{b}/) # => true
|
Repetition If r stands for the immediately preceding regular expression within a pattern, then
r* — matches zero or more occurrences of r.
r+ — matches one or more occurrences of r.
r? — matches zero or one occurrence of r.
r{m,n} — matches at least “m” and at most “n” occurrences of r.
r{m,} — matches at least “m” occurrences of r.
r{m} — matches exactly “m” occurrences of r.
These patterns are called greedy, because by default they will match as much of the string as they can. You can alter this behavior, and have them match the minimum, by adding a question mark suffix (?).regexp, regular expressions How to use Ruby variables in regular expressions If you do not know the pattern that you are trying to match ahead of time (e.g. it is some form of user input), you can construct a regex from a string:
| Repetitiona = "The moon is made of cheese"
show_regexp(a, /\w+/) #-> <<The>> moon is made of cheese
show_regexp(a, /\s.*\s/) #-> The<< moon is made of >>cheese
show_regexp(a, /\s.*?\s/) #-> The<< moon >>is made of cheese
show_regexp(a, /[aeiou]{2,99}/) #-> The m<<oo>>n is made of cheese
show_regexp(a, /mo?o/) #-> The <<moo>>n is made of cheese
|
| |
``, backquote, shell `cmd` → String Returns the standard output of running cmd in a subshell. Command Expansion %x{cmd} – If you enclose a string in backquotes (sometimes called backticks), or use the delimited form prefixed by %x, it will (by default) be executed as a command by your underlying operating system. The value of the expression is the standard output of that command. Newlines will not be stripped, so it is likely that the value you get back will have a trailing return or linefeed character.
– The exit status of the command is available in the global variable $?. Redefining Backquotes The string is passed to the method called Kernel.` (a single backquote). If you want, you can override this.
| Command Expansion`date` #-> "Sun Nov 25 23:50:57 CST 2001\n"
`ls testdir`.split[1] #-> "main.rb"
`ls`.split[34] #-> "book.out"
%x{echo "Hello there"} #-> "Hello there\n"
Escape sequences in the command stringfor i in 0..3
status = `dbmanager status id=#{i}`
end
Redefining Backquotesalias old_backquote `
def `(cmd)
result = old_backquote(cmd)
if $? != 0
fail "Command #{cmd} failed: #$?"
end
result
end
print `date`
print `data`
produces:
Thu Aug 26 22:36:31 CDT 2004
prog.rb:10: command not found: data
prog.rb:5:in ``': Command data failed: 32512 (RuntimeError)
from prog.rb:10
|
select( readArray [, writeArray [ errorArray [timeout] ] ] ) → anArray or nil
IO.select( readArray [, writeArray [ errorArray [timeout] ] ] ) → anArray or nil Performs a low-level select call, which waits for data to become available from input/output devices. The first three parameters are arrays of IO objects or nil. The last is a timeout in seconds, which should be an Integer or a Float. The call waits for data to become available for any of the IO objects in readArray, for buffers to have cleared sufficiently to enable writing to any of the devices in writeArray, or for an error to occur on the devices in errorArray. If one or more of these conditions are met, the call returns a three-element array containing arrays of the IO objects that were ready. Otherwise, if there is no change in status for timeout seconds, the call returns nil. If all parameters are nil, the current thread sleeps forever.
| selectselect( [$stdin], nil, nil, 1.5 ) # [[#<IO:0x401ba090>], [], []]
|
Integer(arg) → Integer Converts "arg" to a Fixnum or Bignum. Numeric types are converted directly (with floating point numbers being truncated).
If "arg" is a String, leading radix indicators (0, 0b, and 0x) are honored. This behavior is different from that of String.to_i
| IntegerInteger(123.999) #-> 123
Integer("0x1a") #-> 26
Integer(Time.new) #-> 1023599977
Integer("123") #-> 123
Integer("123.5") #-> invalid value for Integer: "123.5" (ArgumentError)
|
Float(arg) → Float Returns arg converted to a float.
Numeric types are converted directly, nil is converted to 0.0, and the rest are converted using arg.to_f
| FloatFloat(1) #-> 1.0
Float(nil) #-> 0.0
Float("123.456") #-> 123.456
|
String(arg) → String Converts arg to a String by calling its to_s method.
| StringString(self) #-> "main"
String(self.type) #-> "Object"
String(123456) #-> "123456"
|
Array(arg) → Array Returns arg.to_a Merge Array Merge Array merge return array
| ArrayArray(1..5) #-> [1, 2, 3, 4, 5]
Array Mergearray1=[2,1,3]
array2=[4,5,6]
array3 = array1 | array2
#->[2,1,3,4,5,6]
|
abort Terminate execution immediately, effectively by calling Kernel.exit(1)
| |
at_exit { block } → ProcConverts block to a Proc object (and therefore binds it at the point of call) and registers it for execution when the program exits.
If multiple handlers are registered, they are executed in reverse order of registration.
| at_exitdef do_at_exit(str1)
at_exit { print str1 }
end
at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit
produces:
goodbye cruel world
|
autoload(Module, File) → nil Registers File to be loaded (using Kernel::require ) the first time that Module (which may be a String or a symbol) is accessed.
| autoloadautoload :MyModule, "/usr/local/lib/modules/my_module.rb"
|
context binding → aBinding Returns a Binding object, describing the variable and method bindings at the point of call. This object can be used when calling eval to execute the evaluated command in this environment.
| bindingdef getBinding(param)
return binding
end
b = getBinding("hello")
eval "param", b #-> "hello"
|
block_given? → true or false Returns true if yield would execute a block in the current context.
| block_given?def try
if block_given?
yield
else
"no block"
end
end
try #-> "no block"
try { "hello" } #-> "hello"
try do
"hello"
end
|
random, randomize, rnd rand( max=0 ) → Number Converts max to an integer using max = max.to_i.abs. If the result is zero, returns a pseudorandom floating point number greater than or equal to 0.0 and less than 1.0. Otherwise, returns a pseudorandom integer greater than or equal to zero and less than max.
– Kernel::srand may be used to ensure repeatable sequences of random numbers between different runs of the program. srand( [ Number ] ) → oldSeed – Seeds the pseudorandom number generator to the value of Number.to_i.abs.
– If Number is omitted or zero, seeds the generator using a combination of the time, the process id, and a sequence number. (This is also the behavior if Kernel::rand is called without previously calling srand, but without the sequence.) By setting the seed to a known value, scripts can be made deterministic during testing.
– The previous seed value is returned.
| rand, srandsrand 1234 #-> 0
[rand, rand] #-> [0.7408769294, 0.2145348572]
[rand(10), rand(1000)] #-> [3, 323]
srand 1234 #-> 1234
[rand, rand] #-> [0.7408769294, 0.2145348572]
|
callcc {|cont| block } → ObjectGenerates a Continuation object, which it passes to the associated block. Performing a cont.call will cause the callcc to return (as will falling through the end of the block). The value returned by the callcc is the value of the block, or the value passed to cont.call. Also see Kernel::throw for an alternative mechanism for unwinding a call stack.
| |
caller( [Integer] ) → Array Returns the current execution stack – an array containing strings in the form "file:line" or "file:line: in 'method'".
The optional Integer parameter determines the number of initial stack entries to omit from the result.
| callerdef a(skip)
caller(skip)
end
def b(skip)
a(skip)
end
def c(skip)
b(skip)
end
c(0) #-> ["prog:2:in `a'", "prog:5:in `b'", "prog:8:in `c'", "prog:10"]
c(1) #-> ["prog:5:in `b'", "prog:8:in `c'", "prog:11"]
c(2) #-> ["prog:8:in `c'", "prog:12"]
c(3) #-> ["prog:13"]
|
catch( symbol ) {| | block } → ObjectExecutes its block.
If a throw is executed, Ruby searches up its stack for a catch block with a tag corresponding to the throw's symbol. If found, that block is terminated, and catch returns the value given to throw. If throw is not called, the block terminates normally, and the value of catch is the value of the last expression evaluated. catch expressions may be nested, and the throw call need not be in lexical scope.
| catchdef routine(n)
puts n
throw :done if n <= 0
routine(n-1)
end
catch(:done) { routine(3) }
produces:
3
2
1
0
|
% sprintf( aFormatString [, arguments ]*) → String
format( aFormatString [, arguments ]*) → String (Synonym) Returns the string resulting from applying aFormatString to any additional arguments.
– Within the format string, any characters other than format sequences are copied to the result.
– A format sequence consists of a percent sign, followed by optional flags, width, and precision indicators, then terminated with a field type character.
– The field type controls how the corresponding sprintf argument is to be interpreted, while the flags modify that interpretation.
– The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field.
– For numeric fields, the precision controls the number of decimal places displayed.
– For string fields, the precision determines the maximum number of characters to be copied from the string. (Thus, the format sequence %10.10s will always contribute exactly ten characters to the result.)
Field types
b – Convert argument as a binary number.
c – Argument is the numeric code for a single character.
d – Convert argument as a decimal number.
E – Equivalent to 'e', but uses an uppercase E to indicate the exponent.
e – Convert floating point argument into exponential notation with one digit before the decimal point. The precision determines the number of fractional digits (defaulting to six).
f – Convert floating point argument as [[visible space]-]ddd.ddd, where the precision determines the number of digits after the decimal point.
G – Equivalent to 'g', but use an uppercase 'E' in exponent form.
g – Convert a floating point number using exponential form if the exponent is less than -4 or greater than or equal to the precision, or in d.dddd form otherwise.
i – Identical to 'd'.
o – Convert argument as an octal number.
s – Argument is a string to be substituted. If the format sequence contains a precision, at most that many characters will be copied.
u – Treat argument as an unsigned decimal number.
X – Convert argument as a hexadecimal number using uppercase letters.
x – Convert argument as a hexadecimal number.
Flag characters
[space] (bdeEfgGioxXu) – Leave a space at the start of positive numbers.
# (beEfgGoxX) – Use an alternative format. For the conversions 'o', 'x', 'X', and 'b', prefix the result with "0", "0x", "0X", and "0b", respectively. For 'e', 'E', 'f', 'g', and 'G', force a decimal point to be added, even if no digits follow. For 'g' and 'G', do not remove trailing zeros.
+ (bdeEfgGioxXu) – Add a leading plus sign to positive numbers.
- (all) – Left-justify the result of this conversion.
0 (zero) (all) – Pad with zeros, not spaces.
* (all) – Use the next argument as the field width. If negative, left-justify the result. If the asterisk is followed by a number and a dollar sign, use the indicated argument as the width.
| sprintfputs sprintf("%d %04x", 123, 123) #-> "123 007b"
puts sprintf("%08b '%4s'", 123, 123) #-> "01111011 ' 123'"
puts sprintf("%1$*2$s %2$d %1$s", "hello", 8) #-> " hello 8 hello"
puts sprintf("%1$*2$s %2$d", "hello", -8) #-> "hello -8"
puts sprintf("%+g:% g:%-g", 1.23, 1.23, 1.23) #-> "+1.23: 1.23:1.23"
1250799.99 → 1'250'799.<u>99</u>$v = 1250799.99
sprintf("%s.<u>%02d</u>$", v.to_i.to_s.gsub(/(\d)(?=\d{3}$|\d{6}$)/, '\1\''), v*100%100)
produces:
1'250'799.<u>99</u>$
format, sprintf academic example of sprintfputs 'Some gibberish which is'
puts format("%4$s%5$s%6$s%1$s%3$s%2$s", 'ame', 'ein', ' v', 'i', 'n th', 'e s')
puts 'but which is definitely not...'
puts format("...%2$s%4$s%6$s%1$s%4$s%1$s%3$s%5$s%7$s!", 'oo', 'co', ' po', 'd', 'e', 'e v', 'try').upcase
|
ios.printf(format_string [, obj, ...] ) → nil Formats and writes to ios
| Outprintf("%.2f MB / %d MB (%.f%%)", 12.75, 80.533, 0.1583201917226*100)
produces:
12.75 MB / 80 MB (16%)
|
| |
It’s a Ruby manual
Just type the word or symbol you are looking for
feed and watch for project evolution
