Errata
The errata list is a list of errors and their corrections that were found after the product was released. If the error was corrected in a later version or reprint the date of the correction will be displayed in the column titled "Date Corrected".
The following errata were submitted by our customers and approved as valid errors by the author or editor.
Color key: Serious technical mistake Minor technical mistake Language or formatting error Typo Question Note Update
Version | Location | Description | Submitted By | Date submitted | Date corrected |
---|---|---|---|---|---|
Printed | Page 5 Change: |
"%d %s" % [3, "rubies"] # => "3 Rubies": Python-style, printf formatting To: "%d %s" % [3, "rubies"] # => "3 rubies": Python-style, printf formatting ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 5 Change: |
"%d %s" % [3, "rubies"] # => "3 Rubies": Python-style, printf formatting To: "%d %s" % [3, "rubies"] # => "3 rubies": Python-style, printf formatting ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Safari Books Online | 6.8.3 2nd code in section 6.8.3 |
from: module Functional .... omission.... # Example: # product = lambda {|x,y| x*y} # doubler = lambda >> 2 <== here to: module Functional .... omission.... # Example: # product = lambda {|x,y| x*y} # doubler = product >> 2 <== here |
Anonymous | Jul 20, 2008 | |
Printed | Page 11 Bottom of the page |
Change "there is one alternative implementation relased at a 1.0 level (JRuby)" to "there is one alternative implementation (JRuby) released" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 11 Bottom of the page |
Change "there is one alternative implementation relased at a 1.0 level (JRuby)" to "there is one alternative implementation (JRuby) released" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 12 Top of page |
Change "JRuby 1.0" to "JRuby 1.1" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 12 Top of page |
Change "JRuby 1.0" to "JRuby 1.1" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed, PDF | Page 27 8th line from the bottom |
# Headings begin with an equals sign Comment: End the sentence with a period (.) like # Headings begin with an equals sign. |
Anonymous | Apr 08, 2012 | |
Printed | Page 42 Cut "(standard library)" from the figure in 3 boxes |
---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 42 Cut "(standard library)" from the figure in 3 boxes |
---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 43 top |
Change the first paragraph on the page to: The Complex class represents complex numbers, of course. BigDecimal represents real numbers with arbitrary precision, using a decimal representation rather than a binary representation. And Rational represents rational numbers: one integer divided by another. In Ruby 1.8 these classes are in the standard library. In Ruby 1.9, Complex and Rational are built-in. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 43 top |
Change the first paragraph on the page to: The Complex class represents complex numbers, of course. BigDecimal represents real numbers with arbitrary precision, using a decimal representation rather than a binary representation. And Rational represents rational numbers: one integer divided by another. In Ruby 1.8 these classes are in the standard library. In Ruby 1.9, Complex and Rational are built-in. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 44 Before the box |
Change this: The modulo (%) operator computes remainder-after-integer division: x = 5%2 # result is 1 The % operator can also be used with Float operands, although this is less common: x = 1.5%0.4 # result is 0.3 To this: The modulo (%) operator (and the synonymous modulo method) compute the remainder after integer division. They can also be used with Float and Rational operands. The divmod returns both quotient and modulo: x = 5%2 # => 1: quotient is 2, with 1 left over q,r = 10.divmod 3 # => [3,1]: quotient is 3, remainder is 1 ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 44 middle of the page |
Change this: The division operator depends on the class of the operands. If both operands are integers, then the operation performed is truncating-integer division. If either operand is a Float, then floating-point division is performed: x = 5/2 # result is 2 y = 5.0/2 # result is 2.5 z = 5/2.0 # result is 2.5 To: The division operator depends on the class of the operands: if both operands are integers, then truncating integer division is performed. If either operand is a Float, then floating-point division is performed. There are also three division methods: div performs integer division, fdiv performs floating-point division, and quo returns a Rational when possible, and otherwise returns a Float (this requires the 'rational' module in Ruby 1.8). [5/2, 5.0/2, 5/2.0] # => [2, 2.5, 2.5] [5.0.div(2), 5.0.fdiv(2), 5.quo(2)] # => [2, 2.5, Rational(5,2)] ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 44-45 The text on these pages has been shorted in several places |
without changing its meaning, and the box about "Division, Modulo and Negative Numbers" has been moved from the middle of 3.1.3 to the end of the section. These are non-technical changes required to fit the previous technical changes on the page. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 44 middle of the page |
Change this: The division operator depends on the class of the operands. If both operands are integers, then the operation performed is truncating-integer division. If either operand is a Float, then floating-point division is performed: x = 5/2 # result is 2 y = 5.0/2 # result is 2.5 z = 5/2.0 # result is 2.5 To: The division operator depends on the class of the operands: if both operands are integers, then truncating integer division is performed. If either operand is a Float, then floating-point division is performed. There are also three division methods: div performs integer division, fdiv performs floating-point division, and quo returns a Rational when possible, and otherwise returns a Float (this requires the 'rational' module in Ruby 1.8). [5/2, 5.0/2, 5/2.0] # => [2, 2.5, 2.5] [5.0.div(2), 5.0.fdiv(2), 5.quo(2)] # => [2, 2.5, Rational(5,2)] ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 44 Before the box |
Change this: The modulo (%) operator computes remainder-after-integer division: x = 5%2 # result is 1 The % operator can also be used with Float operands, although this is less common: x = 1.5%0.4 # result is 0.3 To this: The modulo (%) operator (and the synonymous modulo method) compute the remainder after integer division. They can also be used with Float and Rational operands. The divmod returns both quotient and modulo: x = 5%2 # => 1: quotient is 2, with 1 left over q,r = 10.divmod 3 # => [3,1]: quotient is 3, remainder is 1 ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 44-45 The text on these pages has been shorted in several places |
without changing its meaning, and the box about "Division, Modulo and Negative Numbers" has been moved from the middle of 3.1.3 to the end of the section. These are non-technical changes required to fit the previous technical changes on the page. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 52 2nd paragraph |
The following sentence... After these lines have been read, the three string literals are concatenated into one. ...should also indicate that the the string concatenation is joined by newlines... After these lines have been read, the three string literals are concatenated into one, joined by newlines (\n). Note from the Author or Editor: |
Anonymous | Jun 23, 2008 | Dec 01, 2008 |
Printed | Page 53 End of 3.2.1.6 |
The code example... listing = Kernel.`(listcmd) ...is missing a closing `, but in either case (with or without a closing `) results in errors: listcmd = 'ls' => "ls" listing = Kernel.`(listcmd) `# had to enter closing ` to proceed SyntaxError: compile error (irb):46: unterminated string meets end of file from (irb):46 from :0 listing = Kernel.`(listcmd)` SyntaxError: compile error (irb):47: syntax error, unexpected tXSTRING_BEG, expecting $end from (irb):47 from :0 Note from the Author or Editor: |
Anonymous | Jun 23, 2008 | Dec 01, 2008 |
Printed | Page 59 Section 3.2.6.1 |
Change the second paragraph and the block of code that follows it to read: If a string contains multibyte characters, then the number of bytes does not correspond to the number of characters. In Ruby 1.9, the length and size methods return the number of characters in a string, and the new bytesize method returns the number of bytes. The [] and []= operators allow you to query and set the characters of a string, and the new methods getbyte and setbyte allow you to query and set individual bytes (though you should not often need to do this): # -*- coding: utf-8 -*- # Specify Unicode UTF-8 characters # This is a string literal containing a multibyte multiplication character s = "2√ó2=4" # The string contains 6 bytes which encode 5 characters s.bytesize # => 6 s.bytesize.times {|i| print s.getbyte(i), " "} # Prints "50 195 151 50 61 52" s.length # => 5 s.length.times { |i| print s[i], " "} # Prints "2 √ó 2 = 4" s.setbyte(5, s.getbyte(5)+1); # s is now "2√ó2=5" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 59 Section 3.2.6.1 |
Change the second paragraph and the block of code that follows it to read: If a string contains multibyte characters, then the number of bytes does not correspond to the number of characters. In Ruby 1.9, the length and size methods return the number of characters in a string, and the new bytesize method returns the number of bytes. The [] and []= operators allow you to query and set the characters of a string, and the new methods getbyte and setbyte allow you to query and set individual bytes (though you should not often need to do this): # -*- coding: utf-8 -*- # Specify Unicode UTF-8 characters # This is a string literal containing a multibyte multiplication character s = "2√ó2=4" # The string contains 6 bytes which encode 5 characters s.bytesize # => 6 s.bytesize.times {|i| print s.getbyte(i), " "} # Prints "50 195 151 50 61 52" s.length # => 5 s.length.times { |i| print s[i], " "} # Prints "2 √ó 2 = 4" s.setbyte(5, s.getbyte(5)+1); # s is now "2√ó2=5" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 60 top of page |
Change "When you use the [] operator to access" to "When you use the [] operator, as we did in the code above, to access". ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 60 Code in the middle of the page |
Change this line: t.encoding # => <Encoding: ASCII-8BIT> To: t.encoding # => <Encoding: US-ASCII> ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 60 In 2nd paragraph of the box |
Delete this text: Because the "BINARY" encoding really means "unencoded bytes," you can also specify this encoding by passing nil instead of an encoding name or Encoding object. Add this sentence at the end of the 3rd paragraph: The encoding name "ASCII" is an alias for "US-ASCII". ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 60 top of page |
Change "When you use the [] operator to access" to "When you use the [] operator, as we did in the code above, to access". ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 60 Code in the middle of the page |
Change this line: t.encoding # => <Encoding: ASCII-8BIT> To: t.encoding # => <Encoding: US-ASCII> ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 60 In 2nd paragraph of the box |
Delete this text: Because the "BINARY" encoding really means "unencoded bytes," you can also specify this encoding by passing nil instead of an encoding name or Encoding object. Add this sentence at the end of the 3rd paragraph: The encoding name "ASCII" is an alias for "US-ASCII". ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 62 Just before 3.2.6.2. |
Change "raises an exception;" to "raises an exception:" Change the two lines of code that follow to: "u20AC".encode("iso-8859-1") # No euro sign in Latin-1, so raise exception Then add this new paragraph: encode and encode! accept a hash of transcoding options as their final argument. At the time of this writing, the only defined option name is :invalid, and the only defined value for that key is :ignore. "ri String.encode" will give details when more options are implemented. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 62 Just before 3.2.6.2. |
Change "raises an exception;" to "raises an exception:" Change the two lines of code that follow to: "u20AC".encode("iso-8859-1") # No euro sign in Latin-1, so raise exception Then add this new paragraph: encode and encode! accept a hash of transcoding options as their final argument. At the time of this writing, the only defined option name is :invalid, and the only defined value for that key is :ignore. "ri String.encode" will give details when more options are implemented. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 63 |
In the first paragraph, delete: but these are dynamically loaded as needed rather than built-in, and constants do not exist for these encodings until they are used. Change the 4th paragraph on the page from: If you want a list of available encodings, call Encoding.list, which returns an array of Encoding objects. The Encoding.list method only lists built-in encodings and any encodings that have already been dynamically loaded. Calling Encoding.find can cause new encodings to be loaded. These new encodings will be listed by subsequent calls to Encoding.list. To: Encoding.list returns an array of all available encoding objects. Encoding.name_list returns an array of the names (as strings) of all available encodings. Many encodings have more than one name in common use, and Encoding.aliases returns a hash that maps encoding aliases to the official encoding names for which they are synonyms. The array returned by Encoding.name_list includes the aliases in the Encoding.aliases hash. In the 6th paragraph, cut: will also accept nil as a synonym for Encoding::BINARY (i.e., unencoded bytes). Most methods In the same paragraph change "an encoding name" to "a case-insensitive encoding name" Finally, delete the entire last paragraph of Section 3.2.6.2. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 63 |
In the first paragraph, delete: but these are dynamically loaded as needed rather than built-in, and constants do not exist for these encodings until they are used. Change the 4th paragraph on the page from: If you want a list of available encodings, call Encoding.list, which returns an array of Encoding objects. The Encoding.list method only lists built-in encodings and any encodings that have already been dynamically loaded. Calling Encoding.find can cause new encodings to be loaded. These new encodings will be listed by subsequent calls to Encoding.list. To: Encoding.list returns an array of all available encoding objects. Encoding.name_list returns an array of the names (as strings) of all available encodings. Many encodings have more than one name in common use, and Encoding.aliases returns a hash that maps encoding aliases to the official encoding names for which they are synonyms. The array returned by Encoding.name_list includes the aliases in the Encoding.aliases hash. In the 6th paragraph, cut: will also accept nil as a synonym for Encoding::BINARY (i.e., unencoded bytes). Most methods In the same paragraph change "an encoding name" to "a case-insensitive encoding name" Finally, delete the entire last paragraph of Section 3.2.6.2. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 65 |
Change this line: a[-9] = 81 # Error: can't assign before the start of an array To this: a[-10] = 100 # Error: can't assign before the start of an array ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 65 |
Change this line: a[-9] = 81 # Error: can't assign before the start of an array To this: a[-10] = 100 # Error: can't assign before the start of an array ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 66 |
Change this sentence (in the middle of the page): Use << to append elements to the end of an existing array: So that it reads: Use << to append an element to the end of an existing array, and use concat to append the elements of an array: Then, at the end of the code block that follows, add this line: a.concat [7,8] # a is [1, 2, 3, [4, 5, 6], 7, 8] Line up the # mark with the ones above it, of course. Also, move the paragraph that begins "The - operator subtracts" and the one line of code that follows it, so that it comes after this discussion of << and concat (and before the paragraph that begins "Like the String class..." ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 66 |
Change this sentence (in the middle of the page): Use << to append elements to the end of an existing array: So that it reads: Use << to append an element to the end of an existing array, and use concat to append the elements of an array: Then, at the end of the code block that follows, add this line: a.concat [7,8] # a is [1, 2, 3, [4, 5, 6], 7, 8] Line up the # mark with the ones above it, of course. Also, move the paragraph that begins "The - operator subtracts" and the one line of code that follows it, so that it comes after this discussion of << and concat (and before the paragraph that begins "Like the String class..." ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 75 2nd code block |
Change: o.class == String # true if is o a String To: o.class == String # true if o is a String ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 75 2nd code block |
Change: o.class == String # true if is o a String To: o.class == String # true if o is a String ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 80 1st para of 3.8.7.1 |
Add this sentence to the end of the paragraph: Ruby 1.9 adds to_c and to_r methods to convert to Complex and Rational. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 80 1st para of 3.8.7.1 |
Add this sentence to the end of the paragraph: Ruby 1.9 adds to_c and to_r methods to convert to Complex and Rational. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 83 3rd line |
Change "one internal state" to "internal state" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 83 3rd line |
Change "one internal state" to "internal state" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 99 1st full paragraph. |
Change this paragraph: In Ruby 1.8, array, range, and hash rvalues can be splatted. In Ruby 1.9, array, range, and enumerator (see 5.3.4) rvalues can be splatted. If you apply a splat to a value of some other class, that value simply expands to itself. You can define your own splattable classes. In Ruby 1.8, define a to_ary method that returns an array of values. In Ruby 1.9, name the method to_splat instead. Please replace it with: Array, range and hash rvalues can be splatted. In general, any rvalue that defines a to_a method can be prefixed with a splat. Any Enumerable object, including enumerators (see 5.3.4) can be splatted, for example. When a splat is applied to an object that does not define a to_a method, no expansion is performed and the splat evaluates to the object itself. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 99 1st full paragraph. |
Change this paragraph: In Ruby 1.8, array, range, and hash rvalues can be splatted. In Ruby 1.9, array, range, and enumerator (see 5.3.4) rvalues can be splatted. If you apply a splat to a value of some other class, that value simply expands to itself. You can define your own splattable classes. In Ruby 1.8, define a to_ary method that returns an array of values. In Ruby 1.9, name the method to_splat instead. Please replace it with: Array, range and hash rvalues can be splatted. In general, any rvalue that defines a to_a method can be prefixed with a splat. Any Enumerable object, including enumerators (see 5.3.4) can be splatted, for example. When a splat is applied to an object that does not define a to_a method, no expansion is performed and the splat evaluates to the object itself. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 114 4.6.13 last paragraph |
"It is not particularly useful to describe these keywords as operfators.," should be "...operators." |
Anonymous | Jun 24, 2008 | Nov 01, 2008 |
Printed | Page 127 last line of section 5.2 |
Change "documented in later" to "documented later" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 127 last line of section 5.2 |
Change "documented in later" to "documented later" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 130 Iterators box |
Change "(in Ruby 1.9)" to "(in Ruby 1.9 and 1.8.7)" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 130 Iterators box |
Change "(in Ruby 1.9)" to "(in Ruby 1.9 and 1.8.7)" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 135 1st paragraph of 5.3.4 |
Change the 3rd and 4th sentences of this paragraph to read: In Ruby 1.9 (and also 1.8.7), enumerators are built-in and no require is necessary. (As we'll see later, the built-in enumerators have substantially more functionality than that provided by the enumerator library.) ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 135 1st paragraph of 5.3.4 |
Change the 3rd and 4th sentences of this paragraph to read: In Ruby 1.9 (and also 1.8.7), enumerators are built-in and no require is necessary. (As we'll see later, the built-in enumerators have substantially more functionality than that provided by the enumerator library.) ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 136 2nd paragraph |
Change "In Ruby 1.9" to "In Ruby 1.9 (and 1.8.7)" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 136 footnote |
Remove the footnote on this page ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 136 2nd paragraph |
Change "In Ruby 1.9" to "In Ruby 1.9 (and 1.8.7)" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 136 footnote |
Remove the footnote on this page ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 137 Section 5.3.5 |
In the 2nd sentence of this section, change "In Ruby 1.9" to "In Ruby 1.9 (and 1.8.7, though the implementation is not as efficient)" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 137 Section 5.3.5 |
In the 2nd sentence of this section, change "In Ruby 1.9" to "In Ruby 1.9 (and 1.8.7, though the implementation is not as efficient)" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 139 Change the last word before Example 5-1 from "enumerators" to |
"Ruby 1.9". ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 139 Change the last word before Example 5-1 from "enumerators" to |
"Ruby 1.9". ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 142 2nd paragraph |
Change this line: words.sort! {|x,y| y <=> x } To: words.sort! {|x,y| y.length <=> x.length} ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 142 2nd paragraph |
Change this line: words.sort! {|x,y| y <=> x } To: words.sort! {|x,y| y.length <=> x.length} ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 144 2nd paragraph from bottom |
Change "we might expect be able" to "we might expect to be able" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 144 2nd paragraph from bottom |
Change "we might expect be able" to "we might expect to be able" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 159 2nd from last paragraph |
Change "Expression class" to "Exception class" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 159 2nd from last paragraph |
Change "Expression class" to "Exception class" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 161 3rd line |
Change: puts risky # Try to invoke print the return value. To puts risky # Try to invoke and print the return value. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 161 3rd line |
Change: puts risky # Try to invoke print the return value. To puts risky # Try to invoke and print the return value. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 180 Middle of second to last paragraph |
Remove the word "and" from the sentence: "Methods like these are called predicates and." |
Anonymous | Jun 01, 2008 | Nov 01, 2008 |
Printed | Page 186 1st paragraph |
Change "and can be referred to instance variables" to "and can refer to instance variables" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 186 1st paragraph |
Change "and can be referred to instance variables" to "and can refer to instance variables" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 188 3rd paragraph of Section 6.4.3 |
Clarify this sentence: Suppose we have a method that is declared with o ordinary parameters, d parameters with default values, and one array parameter prefixed with *. By adding this at the end: , and that these parameters appear in some arbitrary order. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 188 3rd paragraph of Section 6.4.3 |
Clarify this sentence: Suppose we have a method that is declared with o ordinary parameters, d parameters with default values, and one array parameter prefixed with *. By adding this at the end: , and that these parameters appear in some arbitrary order. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 192 Section 6.5.1 |
The following typo is in the first line of section 6.5.1: "We've already seen one way to crfate..." it should be: "We've already seen one way to create..." Ps Great Book! my thanks to Dave and 'Matz' |
Anonymous | Sep 18, 2008 | Apr 01, 2008 |
Printed | Page 192 sect. 6.5.1, 1st line |
Change "crfate" to "create" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 192 sect. 6.5.1, 1st line |
Change "crfate" to "create" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 196 Right before 6.5.3 |
Add this new paragraph and code at the end of section 6.5.2 Ruby 1.9 adds a curry method to the Proc class. Calling this method returns a curried version of a proc or lambda. When a curried proc or lambda is invoked with insufficient arguments it returns a new Proc object (also curried) with the given arguments applied. Currying is a common technique in the functional programming paradigm: product = ->(x,y){ x*y } # Define a lambda triple = product.curry[3] # Curry it, then specify the first argument [triple[10],triple[20]] # => [30,60]: lambda {|w,x,y,z| w+x+y+z}.curry[1][2,3][4] # => 10 ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 196 Right before 6.5.3 |
Add this new paragraph and code at the end of section 6.5.2 Ruby 1.9 adds a curry method to the Proc class. Calling this method returns a curried version of a proc or lambda. When a curried proc or lambda is invoked with insufficient arguments it returns a new Proc object (also curried) with the given arguments applied. Currying is a common technique in the functional programming paradigm: product = ->(x,y){ x*y } # Define a lambda triple = product.curry[3] # Curry it, then specify the first argument [triple[10],triple[20]] # => [30,60]: lambda {|w,x,y,z| w+x+y+z}.curry[1][2,3][4] # => 10 ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 202 last sentence before 6.6.2 |
Change "and use a loop variables" to "and use loop variables". ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 202 last sentence before 6.6.2 |
Change "and use a loop variables" to "and use loop variables". ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed, PDF | Page 205 1st line in 6.8.1 |
Comment: mapand -> map and |
Anonymous | Jun 17, 2012 | |
Printed | Page 207 last paragraph |
Insert the following right before "For example:" This is similar to, but not quite the same as currying with the Proc.curry method. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 207 last paragraph |
Insert the following right before "For example:" This is similar to, but not quite the same as currying with the Proc.curry method. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 217 5th paragraph |
I have the Jan 2008 printed version. In section 7.1.4, Defining a to_s Method, is the following code fragment: p = new Point(1,2) puts p Can you instantiate an object using 'new <Object-type>...' as opposed to '<Object-type>.new...'? Thank you, -Jeff Note from the Author or Editor: |
Anonymous | Oct 07, 2008 | Dec 01, 2008 |
Printed | Page 218 Last paragraph |
Change "invoke these method" to "invoke these methods". Also, insert the following sentence before "Thus": (The infrequently-used attr_writer creates setter methods only.) ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 218 Last paragraph |
Change "invoke these method" to "invoke these methods". Also, insert the following sentence before "Thus": (The infrequently-used attr_writer creates setter methods only.) ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 222 4th line from the bottom |
Change: elsif # If o is not a Point To: else # If o is not a Point ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 222 4th line from the bottom |
Change: elsif # If o is not a Point To: else # If o is not a Point ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 223 2nd line from bottom |
Change "elsif" to "else" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 223 2nd line from bottom |
Change "elsif" to "else" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 233 2nd paragraph, 3rd line |
Change "refers to class" to "refers to the class" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 233 2nd paragraph, 3rd line |
Change "refers to class" to "refers to the class" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 235 Box about BasicObject |
Add a new sentence at the end of this box: Methods such as ==, equal?, instance_eval, and __send__, are normally considered to be Object methods even though they are actually defined by BasicObject. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 235 Box about BasicObject |
Add a new sentence at the end of this box: Methods such as ==, equal?, instance_eval, and __send__, are normally considered to be Object methods even though they are actually defined by BasicObject. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 240 3rd paragraph from the bottom |
In "is it actually something different" transpose "it" and "is". |
Anonymous | Nov 06, 2008 | Nov 01, 2008 |
Printed | Page 251 6th line |
Change "instanceof?" to "instance_of?" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 251 4th line of 7.5.3 |
Change: include 'Math' # The Math namespace can be included To: include Math # The Math namespace can be included ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 251 6th line |
Change "instanceof?" to "instance_of?" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 251 4th line of 7.5.3 |
Change: include 'Math' # The Math namespace can be included To: include Math # The Math namespace can be included ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 253 Top of the page |
Insert a new paragraph right before "Despite these overall": Ruby 1.9 also defines a require_relative method. It works like require, except that it ignores the load path and searches relative to the directory from which the invoking code was loaded. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 253 Top of the page |
Insert a new paragraph right before "Despite these overall": Ruby 1.9 also defines a require_relative method. It works like require, except that it ignores the load path and searches relative to the directory from which the invoking code was loaded. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 255 |
Change these lines of code: # Add the installation directory for the current program to # the beginning of the load path To: # Add the installation directory for the current program to # the beginning of the load path instead of using require_relative ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 255 |
Change these lines of code: # Add the installation directory for the current program to # the beginning of the load path To: # Add the installation directory for the current program to # the beginning of the load path instead of using require_relative ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 267 Last sentence before 8.1.1 |
Change "Passes" to "Pass" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 267 In the large block of code in 8.1.1 |
Change this line: Integer <Comparable # => true: integers are comparable To add a space: Integer < Comparable # => true: integers are comparable ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 267 Last sentence before 8.1.1 |
Change "Passes" to "Pass" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 267 In the large block of code in 8.1.1 |
Change this line: Integer <Comparable # => true: integers are comparable To add a space: Integer < Comparable # => true: integers are comparable ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 271 Last paragraph before 8.3.1 |
In the first sentence of the paragraph, insert "local_variables," after "global_variables,". Then delete the second sentence ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 271 Last paragraph before 8.3.1 |
In the first sentence of the paragraph, insert "local_variables," after "global_variables,". Then delete the second sentence ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 271 8.3.1 second paragraph |
eval *can* indeed define new instance variables. What it can not do is to define new *local* variables. class C def bar eval('@var = 55') #instance variable @var NOT local to eval self end def foo; puts @var # prints "55" end end C.new.bar.foo Note from the Author or Editor: |
Anonymous | Sep 30, 2008 | Dec 01, 2008 |
Printed | Page 304 4th line from bottom |
Change the line: s.insert(5, " there") # Same as s[5] = " there". Alters s. Returns new s. So that it reads: s.insert(5, " there") # Same as s[5,0] = " there". Alters s. Returns new s. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 304 4th line from bottom |
Change the line: s.insert(5, " there") # Same as s[5] = " there". Alters s. Returns new s. So that it reads: s.insert(5, " there") # Same as s[5,0] = " there". Alters s. Returns new s. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 305 top |
Change these lines: s.length # => 5: counts characters in 1.9, bytes in 1.8 s.size # => 5: size is a synonym s.bytesize # => 5: length in bytes; Ruby 1.9 only To: s.length # => 11: counts characters in 1.9, bytes in 1.8 s.size # => 11: size is a synonym s.bytesize # => 11: length in bytes; Ruby 1.9 only ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 305 near middle of the page |
Change this line: s.start_with? "hell" # => true. Note singular "start" not "starts" To this: s.start_with? "hell" # => true. Note start_with not starts_with ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 305 bottom |
Add these two lines of code at the bottom of the page # In Ruby 1.9, you can specify a hash to map matches to replacements s.gsub(/[aeiou]/,"a"=>0, "e"=>1, "i"=>2) # => "h1ll" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 305 top |
Change these lines: s.length # => 5: counts characters in 1.9, bytes in 1.8 s.size # => 5: size is a synonym s.bytesize # => 5: length in bytes; Ruby 1.9 only To: s.length # => 11: counts characters in 1.9, bytes in 1.8 s.size # => 11: size is a synonym s.bytesize # => 11: length in bytes; Ruby 1.9 only ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 305 near middle of the page |
Change this line: s.start_with? "hell" # => true. Note singular "start" not "starts" To this: s.start_with? "hell" # => true. Note start_with not starts_with ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 305 bottom |
Add these two lines of code at the bottom of the page # In Ruby 1.9, you can specify a hash to map matches to replacements s.gsub(/[aeiou]/,"a"=>0, "e"=>1, "i"=>2) # => "h1ll" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 311 last paragraph |
Change "Ruby 1.9" to "Ruby 1.9 (and 1.8.7)" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 311 last paragraph |
Change "Ruby 1.9" to "Ruby 1.9 (and 1.8.7)" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 319 Section 9.2.4.3 |
In the block of code in the middle of the page, change: phone.gsub!(/D/, "") # Remove anything other than digits To: phone.gsub!(/D/,' '=>'-') # 1.9: remove non-digits but map space to hyphen Insert the following after the first sentence of the last paragraph on the page: (Replacement strings specified in a hash must be ordinary strings, however.) ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 319 Section 9.2.4.3 |
In the block of code in the middle of the page, change: phone.gsub!(/D/, "") # Remove anything other than digits To: phone.gsub!(/D/,' '=>'-') # 1.9: remove non-digits but map space to hyphen Insert the following after the first sentence of the last paragraph on the page: (Replacement strings specified in a hash must be ordinary strings, however.) ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 321 near middle of the page |
Change these lines: 1.scalar? # => false: not a complex number. Ruby 1.9. 1.0.scalar? # => false: not a complex number. Ruby 1.9. Complex(1,2).scalar? # => true: a complex number. requires 'complex'. So they read: 1.scalar? # => true: not a complex number. Ruby 1.9. 1.0.scalar? # => true: not a complex number. Ruby 1.9. Complex(1,2).scalar? # => false: a complex number. require 'complex' in 1.8 ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 321 near middle of the page |
Change these lines: 1.scalar? # => false: not a complex number. Ruby 1.9. 1.0.scalar? # => false: not a complex number. Ruby 1.9. Complex(1,2).scalar? # => true: a complex number. requires 'complex'. So they read: 1.scalar? # => true: not a complex number. Ruby 1.9. 1.0.scalar? # => true: not a complex number. Ruby 1.9. Complex(1,2).scalar? # => false: a complex number. require 'complex' in 1.8 ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 322 in section 9.3.1 |
Change the sentence at the top of the page to: Numeric and its subclasses define various methods for rounding numbers: After the code block, change "Float also defines a few other" to "Here are a few other numeric" Then replace the final block of code in 9.3.1 with this: # For any Numeric value n, in Ruby 1.9 [n.abs, n<=>0] # Absolute value and sign [n.abs, n.angle] # Magnitude and angle (or use n.polar) [n.numerator, n.denominator] # Numerator and denominator [n.real, n.imag] # Real and imaginary parts # Floating point constants: may be implementation dependent [Float::MAX, Float::MIN] # => [1.79769313486232e+308,2.2250738585072e-308] Float::EPSILON # => 2.22044604925031e-16: difference between adjacent floats ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 322 in 9.3.2 |
Insert this line: Math.cbrt(27.0) # => 3.0: cube root; Ruby 1.9 and later After this line: Math.sqrt(25.0) # => 5.0: square root ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 322 in 9.3.2 |
Delete the quotation mark from this line: Math.exp(2) # => 7.38905609893065": same as Math::E**2 ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 322 in section 9.3.1 |
Change the sentence at the top of the page to: Numeric and its subclasses define various methods for rounding numbers: After the code block, change "Float also defines a few other" to "Here are a few other numeric" Then replace the final block of code in 9.3.1 with this: # For any Numeric value n, in Ruby 1.9 [n.abs, n<=>0] # Absolute value and sign [n.abs, n.angle] # Magnitude and angle (or use n.polar) [n.numerator, n.denominator] # Numerator and denominator [n.real, n.imag] # Real and imaginary parts # Floating point constants: may be implementation dependent [Float::MAX, Float::MIN] # => [1.79769313486232e+308,2.2250738585072e-308] Float::EPSILON # => 2.22044604925031e-16: difference between adjacent floats ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 322 in 9.3.2 |
Insert this line: Math.cbrt(27.0) # => 3.0: cube root; Ruby 1.9 and later After this line: Math.sqrt(25.0) # => 5.0: square root ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 322 in 9.3.2 |
Delete the quotation mark from this line: Math.exp(2) # => 7.38905609893065": same as Math::E**2 ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 323 top |
Change the following lines: # Decompose float x into fraction f and exponent e, such that x = f*2**e f,e = frexp(1024.0) # => [0.5, 11] x = ldexp(f, e) # => 1024: compute x = f*2**e # Error function erf(0.0) # => 0.0: error function erfc(0.0) # => 1.0: 1-erf(x): complementary error function To read: # Miscellaneous Functions f,e = frexp(1024.0) # => [0.5, 11]: decompose x into [f,e], x = f*2**e x = ldexp(f, e) # => 1024: compute x = f*2**e erf(0.0) # => 0.0: error function erfc(0.0) # => 1.0: 1-erf(x): complementary error function gamma(5) # => 24.0: floating-point factorial function lgamma(100) # => [359.134205369575, 1]: logarithmic gamma ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 323 bottom |
Change the first paragraph of 9.3.4 to read: The Complex class represents complex numbers. It is a core class in 1.9 and part of the standard library in 1.8. Requiring the 'complex' module (in either 1.8 or 1.9) redefines the methods of the Math module so that they can accept and return complex numbers. In Ruby 1.9 you can instead require 'cmath' to define a CMath module that defines complex-enabled versions of the Math methods. Examples: ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 323 bottom |
Change the first paragraph of 9.3.4 to read: The Complex class represents complex numbers. It is a core class in 1.9 and part of the standard library in 1.8. Requiring the 'complex' module (in either 1.8 or 1.9) redefines the methods of the Math module so that they can accept and return complex numbers. In Ruby 1.9 you can instead require 'cmath' to define a CMath module that defines complex-enabled versions of the Math methods. Examples: ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 323 top |
Change the following lines: # Decompose float x into fraction f and exponent e, such that x = f*2**e f,e = frexp(1024.0) # => [0.5, 11] x = ldexp(f, e) # => 1024: compute x = f*2**e # Error function erf(0.0) # => 0.0: error function erfc(0.0) # => 1.0: 1-erf(x): complementary error function To read: # Miscellaneous Functions f,e = frexp(1024.0) # => [0.5, 11]: decompose x into [f,e], x = f*2**e x = ldexp(f, e) # => 1024: compute x = f*2**e erf(0.0) # => 0.0: error function erfc(0.0) # => 1.0: 1-erf(x): complementary error function gamma(5) # => 24.0: floating-point factorial function lgamma(100) # => [359.134205369575, 1]: logarithmic gamma ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 324 top |
Change the lines of code at the top of the page to the following: require "complex" # Ruby 1.8 and for complex Math methods in 1.9 c = Complex(0.5,-0.2) # => .5-.2i. Complex.polar(1,Math::PI/2) # => Complex(0.0,1.0): create with polar coords i = 1.im # => Complex(0,1): convert to imaginary number (2.re - 3.5.im).to_s # => "2.5-3.5i": re method in Ruby 1.9 only r,i = c.real, c.imag # => [0.5,-0.2]: Real part, imaginary part m,a = c.polar # => [magnitude, angle]: Same as [c.abs,c.angle] d = c.conj # => .5+.2i: change sign of imaginary part z = "0+0i".to_c # String-to-Complex conversion function: 1.9 only 10.times { z = z*z + c } # Arithmetic operators work on Complex numbers 1.im**2 # => Complex(-1,0): i*i == -1 x = Math.sin(z) # 'complex' module redefines Math functions require 'cmath' # Ruby 1.9: Define CMath module for complex math CMath.sqrt(-1)==Complex::I # => true ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 324 9.3.5 |
Change this section to the following: The Rational class represents rational numbers (the quotient of two integers). Rational is built-in to Ruby 1.9 and is part of the standard library in Ruby 1.8. Division with the quo method returns a Rational value if both arguments are integers. Some examples: require "rational" # Only necessary in Ruby 1.8 penny = Rational(1, 100) # A penny is 1/100th nickel = "5/100".to_r # String-to-Rational conversion: Ruby 1.9 only dime = 10.quo 100 # => Rational(1,10) change = 2*dime + 3*penny # => Rational(23,100) change.numerator # => 23: top of the fraction change.denominator # => 100: bottom of the fraction change.to_f # => 0.23: convert to Float (nickel * dime).to_s # => "1/200": to_s returns fractions ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 324 top |
Change the lines of code at the top of the page to the following: require "complex" # Ruby 1.8 and for complex Math methods in 1.9 c = Complex(0.5,-0.2) # => .5-.2i. Complex.polar(1,Math::PI/2) # => Complex(0.0,1.0): create with polar coords i = 1.im # => Complex(0,1): convert to imaginary number (2.re - 3.5.im).to_s # => "2.5-3.5i": re method in Ruby 1.9 only r,i = c.real, c.imag # => [0.5,-0.2]: Real part, imaginary part m,a = c.polar # => [magnitude, angle]: Same as [c.abs,c.angle] d = c.conj # => .5+.2i: change sign of imaginary part z = "0+0i".to_c # String-to-Complex conversion function: 1.9 only 10.times { z = z*z + c } # Arithmetic operators work on Complex numbers 1.im**2 # => Complex(-1,0): i*i == -1 x = Math.sin(z) # 'complex' module redefines Math functions require 'cmath' # Ruby 1.9: Define CMath module for complex math CMath.sqrt(-1)==Complex::I # => true ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 324 9.3.5 |
Change this section to the following: The Rational class represents rational numbers (the quotient of two integers). Rational is built-in to Ruby 1.9 and is part of the standard library in Ruby 1.8. Division with the quo method returns a Rational value if both arguments are integers. Some examples: require "rational" # Only necessary in Ruby 1.8 penny = Rational(1, 100) # A penny is 1/100th nickel = "5/100".to_r # String-to-Rational conversion: Ruby 1.9 only dime = 10.quo 100 # => Rational(1,10) change = 2*dime + 3*penny # => Rational(23,100) change.numerator # => 23: top of the fraction change.denominator # => 100: bottom of the fraction change.to_f # => 0.23: convert to Float (nickel * dime).to_s # => "1/200": to_s returns fractions ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 325 end of section 9.3.7 |
Insert this paragraph: For cryptographically secure random numbers, use the SecureRandom module, which is part of the standard library in Ruby 1.9 and 1.8.7. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 325 end of section 9.3.7 |
Insert this paragraph: For cryptographically secure random numbers, use the SecureRandom module, which is part of the standard library in Ruby 1.9 and 1.8.7. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 329 2nd paragraph |
Change "in Ruby 1.9" to "in Ruby 1.9 (and 1.8.7)". ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 329 middle of the page |
In the paragraph about the zip method, delete this text: in Ruby 1.8 or an enumerator object in Ruby 1.9 (calling to_a on the enumerator object generates the array of arrays that would have been returned in 1.8) Then add the following two lines of code to the code that follows that paragraph: p (1..3).zip('a'..'z') # Prints [[1,"a"],[2,"b"],[3,"c"]] p (1..3).zip('a'..'b') # Prints [[1,"a"],[2,"b"],[3,nil]] ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 329 2nd paragraph |
Change "in Ruby 1.9" to "in Ruby 1.9 (and 1.8.7)". ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 329 middle of the page |
In the paragraph about the zip method, delete this text: in Ruby 1.8 or an enumerator object in Ruby 1.9 (calling to_a on the enumerator object generates the array of arrays that would have been returned in 1.8) Then add the following two lines of code to the code that follows that paragraph: p (1..3).zip('a'..'z') # Prints [[1,"a"],[2,"b"],[3,"c"]] p (1..3).zip('a'..'b') # Prints [[1,"a"],[2,"b"],[3,nil]] ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 330 first paragraph |
Change "Ruby 1.9" to "Ruby 1.9 (and 1.8.7)" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 330 last para before 9.5.1.3 |
Replace the last paragraph before 9.5.1.3 with the following: Finally, note that enumerators, like all Enumerable objects, are splattable: you can prefix an enumerator with an asterisk to expand it into individual values for method invocation or parallel assignment. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 330 first paragraph |
Change "Ruby 1.9" to "Ruby 1.9 (and 1.8.7)" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 330 last para before 9.5.1.3 |
Replace the last paragraph before 9.5.1.3 with the following: Finally, note that enumerators, like all Enumerable objects, are splattable: you can prefix an enumerator with an asterisk to expand it into individual values for method invocation or parallel assignment. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 331 middle of page |
Change the paragraph that begin "In Ruby 1.9" to read: The find_index method (new in Ruby 1.9) is like the index method of Array: it returns the index of a specific element or of the first element that matches a block: Then add this line of code before the two following lines: data.find_index [0,1] # => 1: the second element matches ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 331 middle of page |
Change the paragraph that begin "In Ruby 1.9" to read: The find_index method (new in Ruby 1.9) is like the index method of Array: it returns the index of a specific element or of the first element that matches a block: Then add this line of code before the two following lines: data.find_index [0,1] # => 1: the second element matches ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 333 top of page |
Insert a new paragraph right before 9.5.1.6: The Array class defines its own efficient versions of these taking and dropping methods that do not require arrays to be iterated with each. ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 333 top of page |
Insert a new paragraph right before 9.5.1.6: The Array class defines its own efficient versions of these taking and dropping methods that do not require arrays to be iterated with each. ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 335 9.5.2.2 |
Change: [1,2,3].nitems {|x| x>2} # => 1: # of elts matching block (Ruby 1.9) To: [1,2,3].nitems {|x| x>2} # => 1: # of elts matching block (Ruby 1.9 + 1.8.7) ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Printed | Page 335 in the code of 9.5.2.2 |
Please change this line: a[-a.size-1] # => 'a': first element to read: a[-a.size] # => 'a': first element ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 335 9.5.2.2 |
Change: [1,2,3].nitems {|x| x>2} # => 1: # of elts matching block (Ruby 1.9) To: [1,2,3].nitems {|x| x>2} # => 1: # of elts matching block (Ruby 1.9 + 1.8.7) ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Other Digital Version | 335 in the code of 9.5.2.2 |
Please change this line: a[-a.size-1] # => 'a': first element to read: a[-a.size] # => 'a': first element ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 335 in the middle |
The nitems method of Array has been removed in Ruby 1.9. Delete the following two lines: [1,2,nil].nitems # => 2: number of non-nil elements [1,2,3].nitems {|x| x > 2} # => 1: # of elts matching block (Ruby 1.9) And replace them with these: [1,2,nil].nitems # => 2: number of non-nil elements (Ruby 1.8 only) [1,2,nil].count(nil) # => 1: # of nils (Enumerable method in Ruby 1.9) [1,2,3].count {|x| x > 2} # => 1: # of elts matching block (1.9) |
David Flanagan |
May 28, 2008 | Dec 01, 2008 |
Printed | Page 337 9.5.2.4 |
Add this sentence at the end of the first paragraph In Ruby 1.9 and 1.8.7, array iterators return an enumerator when invoked without a block: ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 337 9.5.2.4 |
Add this sentence at the end of the first paragraph In Ruby 1.9 and 1.8.7, array iterators return an enumerator when invoked without a block: ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 338 code near top of page |
Change these lines: a.index {|c| c =~ /[aeiou]/} # => 1: index of first vowel. Ruby 1.9. a.rindex {|c| c =~ /[aeiou]/} # => 4: index of last vowel. Ruby 1.9. To: a.index {|c| c =~ /[aeiou]/} # => 1: index of 1st vowel. 1.9 and 1.8.7 a.rindex {|c| c =~ /[aeiou]/} # => 4: index of last vowel. 1.9 and 1.8.7 ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 338 code near top of page |
Change these lines: a.index {|c| c =~ /[aeiou]/} # => 1: index of first vowel. Ruby 1.9. a.rindex {|c| c =~ /[aeiou]/} # => 4: index of last vowel. Ruby 1.9. To: a.index {|c| c =~ /[aeiou]/} # => 1: index of 1st vowel. 1.9 and 1.8.7 a.rindex {|c| c =~ /[aeiou]/} # => 4: index of last vowel. 1.9 and 1.8.7 ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 342 In section 9.5.3.3 |
Change this line: h.replace({1=>:a, 2=>;b} # h is now equal to the argument hash To: h.replace({1=>:a, 2=>:b}) # h is now equal to the argument hash ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 342 In section 9.5.3.3 |
Change this line: h.replace({1=>:a, 2=>;b} # h is now equal to the argument hash To: h.replace({1=>:a, 2=>:b}) # h is now equal to the argument hash ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 345 2nd paragraph from the bottom |
Delete the second paragraph from the bottom. Matz says that the compare_by_identity method will likely be removed ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 345 2nd paragraph from the bottom |
Delete the second paragraph from the bottom. Matz says that the compare_by_identity method will likely be removed ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 355 Middle of the page |
Insert the following before "To change the name of a file": To copy a file, use File.copy_stream, specifying filenames as the source and destination: File.copy_stream("test", "test.backup") ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 355 Middle of the page |
Insert the following before "To change the name of a file": To copy a file, use File.copy_stream, specifying filenames as the source and destination: File.copy_stream("test", "test.backup") ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 361 Section 9.7.3.2 |
At the end of the first paragraph, replace this sentence: None of these class methods requires you to instantiate an IO object: With this: In Ruby 1.9, you can pass a hash to these methods to specify the mode string and/or encoding of the file being read. After the first line of code in the section insert these two lines: data = IO.read("data", mode:"rb") # Open with mode string "rb" data = IO.read("data", encoding:"binary") # Read unencoded bytes Insert the following before the paragraph that begins "Although" In Ruby 1.9 you can use IO.copy_stream to read a file (or a portion) and write its content to a stream: IO.copy_stream("/usr/share/dict/words", STDOUT) # Print the dictionary IO.copy_stream("/usr/share/dict/words", STDOUT, 10, 100) # Print bytes 100-109 At the end of the next paragraph, change "and File.foreach" to "File.foreach, and File.copy_stream" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 361 Section 9.7.3.2 |
At the end of the first paragraph, replace this sentence: None of these class methods requires you to instantiate an IO object: With this: In Ruby 1.9, you can pass a hash to these methods to specify the mode string and/or encoding of the file being read. After the first line of code in the section insert these two lines: data = IO.read("data", mode:"rb") # Open with mode string "rb" data = IO.read("data", encoding:"binary") # Read unencoded bytes Insert the following before the paragraph that begins "Although" In Ruby 1.9 you can use IO.copy_stream to read a file (or a portion) and write its content to a stream: IO.copy_stream("/usr/share/dict/words", STDOUT) # Print the dictionary IO.copy_stream("/usr/share/dict/words", STDOUT, 10, 100) # Print bytes 100-109 At the end of the next paragraph, change "and File.foreach" to "File.foreach, and File.copy_stream" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 362 3rd paragraph from bottom |
Replace these lines: Another way to read the bytes of a stream is with the each_byte iterator. This method passes each byte of a stream to the associated block: f.each_byte {|b| ... } # Iterate through remaining bytes f.bytes # An enumerator for each_byte: Ruby 1.9 With these: You can also iterate and enumerate the characters and bytes of a stream: f.each_byte {|b| ... } # Iterate through remaining bytes f.bytes # An enumerator for each_byte: Ruby 1.9 f.each_char {|c} ...} # Iterate characters: Ruby 1.9 f.chars # An enumerator for each_char: Ruby 1.9 ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 362 3rd paragraph from bottom |
Replace these lines: Another way to read the bytes of a stream is with the each_byte iterator. This method passes each byte of a stream to the associated block: f.each_byte {|b| ... } # Iterate through remaining bytes f.bytes # An enumerator for each_byte: Ruby 1.9 With these: You can also iterate and enumerate the characters and bytes of a stream: f.each_byte {|b| ... } # Iterate through remaining bytes f.bytes # An enumerator for each_byte: Ruby 1.9 f.each_char {|c} ...} # Iterate characters: Ruby 1.9 f.chars # An enumerator for each_char: Ruby 1.9 ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 390 last paragraph |
Change "-r, and -K options" to "-r, -K, -E, and -T" options. Change "on the command line" to "on the command line, unless the command line includes --disable-rubyopt ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 390 last paragraph |
Change "-r, and -K options" to "-r, -K, -E, and -T" options. Change "on the command line" to "on the command line, unless the command line includes --disable-rubyopt ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 | |
Printed | Page 398 first line of section 10.2.3.3 |
Change "and variable" to "and variables" ---------------------------------------------------------------------- |
Anonymous | Apr 01, 2008 | |
Other Digital Version | 398 first line of section 10.2.3.3 |
Change "and variable" to "and variables" ---------------------------------------------------------------------- |
Anonymous | Jul 01, 2008 |