Ruby.

nil means no value at all. empty? asks whether a string or collection has no elements, and blank? is a Rails check that also treats nil and whitespace as empty.

• nil is the single object of NilClass. Only nil returns true for nil?, and nil has no empty? method.
• empty? is defined on String, Array and Hash. It is true only when the length is zero, so " ".empty? is false.
• blank? comes from Rails' Active Support, not plain Ruby. It is true for nil, false and empty collections. A string of only whitespace is blank too.

Plain Ruby treats only nil and false as falsy. An empty string and 0 are truthy, which is why blank? is useful for form input.

nil.nil?        # true
"".empty?       # true
[].empty?       # true
" ".blank?      # true (Rails only)

Double quotes process string interpolation and escape sequences, while single quotes keep almost every character exactly as written.

In a double-quoted string, #{name} runs the code inside the braces and inserts the result. Escapes such as \n for a newline and \t for a tab turn into those characters.

In a single-quoted string, #{name} and \n stay as plain text. The only escapes are \' for a quote and \\ for a backslash.

Both forms build the same kind of String object. Use double quotes when the string needs a value or a special character inside it, and single quotes for fixed text.

name = "Alice"
puts "Hello #{name}"   # Hello Alice
puts 'Hello #{name}'   # Hello #{name}
puts "Line\nBreak"     # Line with actual break
puts 'Line\nBreak'     # Line\nBreak literally

A symbol is an immutable name written with a leading colon, like :status. Every use of the same symbol refers to the same object in memory.

Ruby stores each symbol once and represents it internally by an integer ID. That saves memory and makes comparing two symbols fast, because Ruby only checks identity.

Use symbols for hash keys, method names and fixed labels such as :active or :pending. Use strings for text that changes or comes from users. Without the frozen_string_literal magic comment, two identical string literals are two separate objects, so the second comparison below is false.

:status.object_id == :status.object_id  # true
"status".object_id == "status".object_id  # false
# Common usage
user = { name: "John", age: 30 }  # symbols as hash keys

puts and print write the to_s text of a value and return nil, while p writes the inspect form and returns the value itself.

puts adds a newline after each value, and print adds none. Given an array, puts prints each element on its own line.

p shows the developer view of a value. Strings keep their quotes, and nil appears as nil, where puts nil prints an empty line. Because p returns its argument, you can put it in the middle of an expression while debugging and the result does not change.

puts "Hello"    # Hello\n (returns nil)
print "Hello"   # Hello (returns nil)
p "Hello"       # "Hello"\n (returns "Hello")

Ruby has public, protected and private methods. Public is the default.

• Any code can call a public method.
• Code inside the same class or a subclass can call a protected method, even on another object. One object can then compare itself with another of its kind.
• Only the object itself can call a private method, with no receiver, meaning no object before the dot. Since Ruby 2.7, a literal self. also works.

send can still call a private method from outside, so visibility is not a security boundary.

class MyClass
  def public_method; end
  
  protected
  def protected_method; end
  
  private
  def private_method; end
end

each runs the block for its side effects and returns the original array, while map collects the block's results into a new array.

Use each when something should happen for every element, such as printing or saving it. Use map when every element should become a new value.

A common mistake is to call each and expect the transformed values back. each ignores what the block returns, so the numbers.each line below still returns [1, 2, 3].

Neither method changes the original array. The bang version map! replaces the elements in place.

numbers = [1, 2, 3]
numbers.each { |n| n * 2 }  # Returns [1, 2, 3]
numbers.map { |n| n * 2 }   # Returns [2, 4, 6]

merge returns a new hash and leaves the original unchanged, while merge! is destructive, which means it changes the hash you call it on.

Both combine the key-value pairs of the two hashes. When a key exists in both, the value from the argument wins, so :b becomes 3 below. A block, if you pass one, runs only for those shared keys and picks the value, as in h1.merge(h2) { |key, old, new| old + new }.

Use merge when other code still needs the original hash. Use merge! when you own the hash and want to avoid building a copy. The trailing ! is Ruby's convention for the version that changes the object, and update is another name for merge!.

h1 = { a: 1, b: 2 }
h2 = { b: 3, c: 4 }
h1.merge(h2)   # Returns { a: 1, b: 3, c: 4 }, h1 unchanged
h1.merge!(h2)  # h1 is now { a: 1, b: 3, c: 4 }

flatten removes nesting, while compact removes nil values. They solve different problems and are often chained.

• flatten turns nested arrays into one flat array, at every depth by default. Pass a depth to stop early, so [[1, [2]]].flatten(1) gives [1, [2]].
• compact returns a copy without the nil elements. It keeps false and empty strings, because only nil is removed.

When a map block returns arrays, flat_map maps and flattens one level in a single step.

Both return a new array. The bang versions flatten! and compact! change the array in place and return nil when nothing changed.

[[1, 2], [3, [4]]].flatten  # [1, 2, 3, 4]
[1, nil, 2, nil, 3].compact  # [1, 2, 3]

Rails splits an app into models, views and controllers, so data rules, page markup and request handling each live in their own place.

• The model is an Active Record class. It holds the data, the validations and the business rules, and it maps to a database table.
• The view is a template, usually ERB, that turns data into HTML or JSON.
• The controller receives the request, asks models for data, and then renders a view or redirects to another URL.

A request reaches the router first. The router calls a controller action, the action works with models, and the controller sends back the rendered view as the response.

Keeping business rules in models, out of views and controllers, makes them easier to test and reuse.

Ruby uses snake_case for methods and variables, CamelCase for classes and modules, and SCREAMING_SNAKE_CASE for constants, like user_name, UserAccount and MAX_USERS.

A capital first letter makes a name a constant. A prefix sets a variable's scope: @ for instance variables, @@ for class variables and $ for globals.

Method names add two suffixes by convention. A name ending in ? is a predicate that answers true or false, like empty?. A name ending in ! marks a more dangerous version of a method, like save!. It often changes the object it is called on or raises an error.

File names use snake_case and match the class inside, so UserAccount lives in user_account.rb.

The Gemfile lists the gems a project needs, where to get them, and the version ranges it accepts. Gemfile.lock records the exact version Bundler installed for every gem, including the gems those gems depend on.

When you run bundle install and the lock file still matches the Gemfile, Bundler installs exactly those versions. It skips dependency resolution, the step that picks one version of each gem to fit every range. That keeps every developer machine, build server and production host on the same gem versions. bundle update is the step that moves gems to newer versions and rewrites the lock file.

Commit both files for an application.

The safe navigation operator &. calls a method only when the receiver is not nil. When the receiver is nil, it skips the call and returns nil instead of raising NoMethodError.

Use it where nil is an expected value, such as an optional association or a missing hash entry. Each step of a chain needs its own &.. Avoid long &. chains where nil would mean a bug, because they hide the error until later.

It is not exactly the same as &&. &. checks only for nil, so false&.to_s still calls the method. The && version below also calls user.profile twice.

user&.profile&.name  # Returns nil if any part is nil
# Roughly equivalent to:
user && user.profile && user.profile.name

# With arrays
users&.first&.name  # Safe even if users is nil

They write accessor methods for instance variables, so you do not write simple getters and setters by hand. attr_reader :name defines a name method that returns @name, attr_writer :name defines a name= method that sets it, and attr_accessor :name defines both.

Pick the narrowest one. A value that callers should only read gets attr_reader, so the object stays in control of its own changes.

Inside the class, call a writer as self.name = value. Without self, Ruby creates a local variable instead.

class User
  attr_reader :id
  attr_accessor :name

  def initialize(id, name)
    @id = id
    @name = name
  end
end

user = User.new(1, "Ann")
user.name = "Bea"   # writer from attr_accessor
user.name           # "Bea"
user.id = 2         # NoMethodError: no id= writer