Ruby.new

1.   Ruby is a genuine object-oriented language. Everything you manipulate is an object, and the results of those manipulations are themselves objects.

2.  Every object has a unique object identifier (abbreviated as object ID).

3.   puts is a standard Ruby method that writes its argument(s) to the console, adding a newline after each.

 

4.  In Ruby, the ability to determine an absolute value is built into numbers:

 

num = -123

puts num.abs

 

5.  You don’t need semicolons at the ends of statements as long as you put each statement on a separate line.

6.   Ruby comments start with a # character and run to the end of the line.

7.   Methods are defined with the key word def , followed by the method name and the method’s parameters between parentheses. (In fact, the parentheses are optional) Ruby doesn’t use braces to delimit the bodies of compound statements and definitions. Instead, you simply finish the method body with the keyword end .

 

8.     You don’t need to declare a variable, instead you can use a variable directly.

9.   Ruby has many ways to create a string object, but probably the most common is to use string literals, which are sequences of characters between single or double quotation marks. The difference between the two forms is the amount of processing Ruby does on the string while constructing the literal. In the single-quoted case, Ruby does very little. In the double-quoted case, Ruby does more work. First, it looks for substitutions (sequences that start with a backslash character) and replaces them with some binary value. The most common of these is \n , which is replaced with a newline character. The second thing that Ruby does with double-quoted strings is expression interpolation. Within the string, the sequence #{expression} is replaced by the value of expression.

10.   capitalize method, defined for all strings, is to return the string with a leading uppercase letter.

11.  The value returned by a Ruby method is the value of the last expression evaluated, so we can get rid of the temporary variable and the return statement altogether.

12.  The first characters of a name indicate how the name is used. Local variables, method parameters, and method names should all start with a lowercase letter or an underscore. Global variables are prefixed with a dollar sign ($), and instance variables begin with an “at” sign (@). Class variables start with two “at” signs (@@). Finally, class names, module names, and constants must start with an uppercase letter.

13.    Arrays and hashes are indexed collections, accessible using a key. With arrays, the key is an integer, whereas hashes support any object as a key. Both arrays and hashes grow as needed to hold new elements. It’s more efficient to access array elements, but hashes provide more flexibility. Any particular array or hash can hold objects of differing types.

14.  You can create and initialize a new array object using an array literal—a set of elements between square brackets. Ruby array indices start at zero.

15.  nil is an object, just like any other, that happens to represent nothing.

16.  Sometimes creating arrays of words can be a pain, what with all the quotes and commas. Fortunately, Ruby has a shortcut; %w does just what we want: 

a = %w{ ant bee cat dog elk } 

 

17.  A hash literal uses braces rather than square brackets. The literal must supply two objects for every entry: one for the key, the other for the value. The key and value are normally separated by => .The thing to the left of the => is the key, and the thing to the right is the corresponding value. Hashes are indexed using the same square bracket notation as arrays. A hash by default returns nil when indexed by a key it doesn’t contain.

 

18.  p method that writes the values to the console works like puts but displays values such as nil explicitly.

 

19.  To create a hash with default value as 0:

Hash.new(0)

 

20.  Symbols are simply constant names that you don’t have to pre-declare and that are guaranteed to be unique. A symbol literal starts with a colon and is normally followed by some kind of name. There’s no need to assign some kind of value to a symbol. Ruby guarantees that no matter where it appears in your program, a particular symbol will have the same value.

21.  You can use name: value pairs to create a hash if the keys are symbols.

inst_section = {
cello: 'string',
clarinet: 'woodwind',
drum: 'percussion',
oboe: 'woodwind',
trumpet: 'brass',
violin: 'string'
}

 

 

22.  Ruby uses the keyword end to signify the end of a body of all the control structures.

23.  Most statements in Ruby return a value, which means you can use them as conditions. And Ruby treats nil as a false value in conditions.

 

24.  The kernel method gets returns the next line from the standard input stream or nil when the end of the file is reached.

25.  Ruby statement modifiers are a useful shortcut if the body of an if or while statement is just a single expression. Simply write the expression, followed by if or while and the condition: 

puts "Danger, Will Robinson" if radiation > 3000

 

 

26.  In Ruby, you typically create a regular expression by writing a pattern between slash characters (/pattern/ ).

27.  The pipe character “| ” means “either the thing on the right or the thing on the left”. \s , matches a whitespace character (space, tab, newline, and so on); \d , which matches any digit; and \w , matches any character that may appear in a typical word. A dot “. ” matches (almost) any character.

28.  The match operator =~ can be used to match a string against a regular expression. If the pattern is found in the string, =~ returns its starting position; otherwise, it returns nil .

line = gets

if line =~ /Perl|Python/

puts "Scripting language mentioned: #{line}"

end

 

 

29.  T he part of a string matched by a regular expression can be replaced with different text using one of Ruby’s substitution methods: sub which is to replace the first matched text and gsub which is to replace all the matched text. 

line.sub(/Perl/, 'Ruby')

 

30.  Code blocks are chunks of code you can associate with method invocations, almost as if they were parameters. You can use code blocks to implement callbacks (but they’re simpler than Java’s anonymous inner classes), to pass around chunks of code (but they’re more flexible than C’s function pointers), and to implement iterators.

31.  Code blocks are just chunks of code between braces or between do and end . The braces bind more tightly than the do /end pairs. What is becoming a Ruby standard is to use braces for single-line blocks and do /end for multiline blocks.

32.  All you can do with a block is associate it with a call to a method. You do this by putting the start of the block at the end of the source line containing the method call. If the method has parameters, they appear before the block. A method can then invoke an associated block one or more times using the Ruby yield statement. You can think of yield as being something like a method call that invokes the block associated with the call to the method containing the yield .

33.  You can provide arguments to the call to yield , and they will be passed to the block. Within the block, you list the names of the parameters to receive these arguments between vertical bars (|params...| ):

who_says_what {|person, phrase| puts "#{person} says #{phrase}"}

 

34.  Code blocks are used throughout the Ruby library to implement iterators, which are methods that return successive elements from some kind of collection.

35.  

 [ 'cat', 'dog', 'horse' ].each {|name| print name, " " }

5.times { print "*" }

3.upto(6) {|i| print i }

('a'..'e').each {|char| print char } 

 

Here we ask an array to call the block once for each of its elements. Then, object 5 calls a block five times. Rather than use for loops, in Ruby we can ask the number 3 to call a block, passing in successive values until it reaches 6 . Finally, the range of characters from a to e invokes a block using the method each .

 

36.  puts writes its arguments with a newline after each; print also writes its arguments but with no newline. Both can be used to write to any I/O object, but by default they write to standard output.

 

 

37.  printf prints its arguments under the control of a format string (just like printf in C or Perl).

38.  T he array ARGV contains each of the arguments passed to the running program. The variable ARGF is a special kind of I/O object that acts like all the contents of all the files whose names are passed on the command line (or standard input if you don’t pass any filenames).