ruby notes (2)

  • The Ruby ri tool is used to view the Ruby documentation off-line. Open a command window and invoke ri followed by the name of a Ruby class, module or method.

ri Array
ri Array.sort
ri Hash#each
ri Math::sqrt

  • double quoted string does two more thing than single-quoted string:

first, it looks for substitutions – sequences that start with a backslash character – and replaces them with some binary value. second, expression interpolation

a=”hi”
=> “hi”
irb(main):002:0> puts “#{a}”
hi
=> nil
irb(main):003:0> puts ‘#{a}’
#{a}
=> nil

  • block
  • def call_block
    puts ‘Start of method’
    yield # you can call the block using the yield keyword
    yield
    puts ‘End of method’
    end
    # Code blocks may appear only in the source adjacent to a method call
    call_block {puts ‘In the block’}The output is:

    1. Start of method
    2. In the block
    3. In the block
    4. End of method

    If you provide a code block when you call a method, then inside the method, you can yield control to that code block – suspend execution of the method; execute the code in the block; and return control to the method body, right after the call to yield. If no code block is passed, Ruby raises an exception:

    no block given (LocalJumpError)

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

    1. def call_block
    2.   yield(‘hello’, 99)
    3. end
    4. call_block {|str, num| puts str + ‘ ‘ + num.to_s}

    The output is:

    1. >ruby p023codeblock2.rb
    2. hello 99
    3. >Exit code: 0

    Note that the code in the block is not executed at the time it is encountered by the Ruby interpreter. Instead, Ruby remembers the context in which the block appears and then enters the method.

    A code block’s return value (like that of a method) is the value of the last expression evaluated in the code block. This return value is made available inside the method; it comes through as the return value of yield.

    block_given? returns true if yield would execute a block in the current context. Refer to the following example:

    1. def try
    2.   if block_given?
    3.     yield
    4.   else
    5.     puts “no block”
    6.   end
    7. end
    8. try # => “no block”
    9. try { puts “hello” } # => “hello”
    10. try do puts “hello” end # => “hello”

    Block Variables

    Let us see what happens in the following example when a variable outside a block is x and a block parameter is also named x.

    1. x = 10
    2. 5.times do |x|
    3.   puts “x inside the block: #{x}”
    4. end
    5. puts “x outside the block: #{x}”

    The output is:

    1. x inside the block: 0
    2. x inside the block: 1
    3. x inside the block: 2
    4. x inside the block: 3
    5. x inside the block: 4
    6. x outside the block: 10

    You will observe that after the block has executed, x outside the block is the original x. Hence the block parameter x was local to the block.

    Next observe what happens to x in the following example:

    1. x = 10
    2. 5.times do |y|
    3.   x = y
    4.   puts “x inside the block: #{x}”
    5. end
    6. puts “x outside the block: #{x}”

    The output is:

    1. x inside the block: 0
    2. x inside the block: 1
    3. x inside the block: 2
    4. x inside the block: 3
    5. x inside the block: 4
    6. x outside the block: 4

    Since x is not a block parameter here, the variable x is the same inside and outside the block.

    In Ruby 1.9, blocks introduce their own scope for the block parameters only. This is illustrated by the following example:

    1. x = 10
    2. 5.times do |y; x|
    3.   x = y
    4.   puts “x inside the block: #{x}”
    5. end
    6. puts “x outside the block: #{x}”

    The output is:

    1. x inside the block: 0
    2. x inside the block: 1
    3. x inside the block: 2
    4. x inside the block: 3
    5. x inside the block: 4
    6. x outside the block: 10

    In the above block, a new feature is being used: block local variable. In short, block local variables shield a block from manipulating variables outside of its scope. This prevents a block from unintentionally clobbering any variables outside its scope. If you don’t want to clobber variables, use block local variables for the variables your block creates.

    The syntax for a block local variable is simple. Put a semicolon after the normal block parameter list, then list the variable you want as block local variables. For example, if the block takes two variables a and b, and uses to local variables x and y, the parameter list would look like this: |a,b; x,y|.

One thought on “ruby notes (2)

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s