What is a block in Ruby?

In Ruby, a block is a self-contained chunk of code that can be associated with method calls. Blocks are not standalone functions or methods but rather anonymous pieces of code that can be passed as arguments to methods. They are a powerful and flexible feature of Ruby, enabling you to achieve various programming tasks, including iteration, filtering, and customizing method behavior.

Key characteristics of blocks in Ruby:

1. Anonymous: Blocks are anonymous, meaning they don’t have a name and are not assigned to variables. Instead, they are defined inline within method calls.

2. Delimited by `do…end` or Curly Braces `{}`: You can define a block using either the `do…end` syntax or curly braces `{}`. The choice between them is a matter of convention and readability.

 ```ruby

   5.times do

     puts "Hello, world!"

   end




   5.times { puts "Hello, world!" }

   ```

3. Variable Scope: Blocks can access variables from the surrounding scope in which they are defined. This is known as closure. It allows you to use variables from the enclosing method or block inside the block.

 ```ruby

   x = 10

   3.times do

     puts x  # This block can access the variable x

   end

   ```

4. Used for Iteration: Blocks are often used for iteration in Ruby. Methods like `each`, `map`, and `select` accept blocks as arguments, allowing you to define custom behavior for each element in a collection.

  ```ruby

   [1, 2, 3].each do |number|

     puts number * 2

   end

   ```

5. Passing Blocks to Methods: You can pass blocks as arguments to methods, enabling dynamic and customizable behavior. Methods can execute the block using the `yield` keyword.

  ```ruby

   def custom_method

     puts "Before the block"

     yield if block_given?

     puts "After the block"

   end




   custom_method do

     puts "Inside the block"

   end

   ```

Blocks in Ruby are a versatile and powerful feature that allows you to encapsulate and customize behavior within methods, making your code more expressive and adaptable. They are extensively used in Ruby libraries and frameworks, contributing to the language’s flexibility and readability.