rails常見面試問題整理

foo, bar = [], 1
foo ||= bar # foo = foo || bar
foo

a = hsh[:something]
a.send(:=, val)

hsh = Hash.new([])

hsh[:one] << 'one'
hsh[:two] << 'two'

hsh[:nonexistent]
# => ['one', 'two']

hsh
# => {}

hsh = Hash.new([])

hsh[:one] += ['one']
hsh[:two] += ['two']
# This is syntactic sugar for hsh[:two] = hsh[:two] + ['two']

hsh[:nonexistant]
# => []

hsh
# => { :one => ['one'], :two => ['two'] }

hsh = Hash.new { [] }
# This time, instead of a default *value*, we use a default *block*

hsh[:one] << 'one'
hsh[:two] << 'two'

hsh[:nonexistent]
# => []
# We *did* mutate the default value, but it was a fresh one every time.

hsh
# => {}
# But we never mutated the hash itself, therefore it is still empty!

hsh = Hash.new {|hsh, key| hsh[key] = [] }

hsh[:one] << 'one'
hsh[:two] << 'two'

hsh[:nonexistent]
# => []
# We *did* mutate the default value, but it was a fresh one every time.

hsh
# => { :one => ['one'], :two => ['two'], :nonexistent => [] }

def whowouldwin

  mylambda = lambda {return "Freddy"}
  mylambda.call

  # mylambda gets called and returns "Freddy", and execution
  # continues on the next line

  return "Jason"

end


whowouldwin
#=> "Jason"

# Proc returns control not just from the proc, but also from the method enclosing the proc!
def whowouldwin2

  myproc = Proc.new {return "Freddy"}
  myproc.call

  # myproc gets called and returns "Freddy", 
  # but also returns control from whowhouldwin2!
  # The line below *never* gets executed.

  return "Jason"

end


whowouldwin2         
#=> "Freddy"

p Fixnum === 1 # => true
p 1 === Fixnum # => false
p 100 == 100.0 # => true
p 100.eql? 100.0 # => false

# x 就是物件，caller，或是receiver
(1..5).tap { |x| puts "element: #{x.inspect}" }.to_a
  # => element: 1..5
  .tap { |x| puts "array: #{x.inspect}" }
  # => array: [1, 2, 3, 4, 5]
  .select { |x| x%2 == 0 }
  .tap{ |x| puts "evens: #{x.inspect}" }
   # => evens: [2, 4]
  .map{ |x| x*x }
  .tap{ |x| puts "squares: #{x.inspect}" }
   # => squares: [4, 16]

[ "", " ", false, nil, [], {} ].any?(&:present?)
# => false

User.where(name: 'mike').present?
# User Load (8.1ms) SELECT "users".* FROM "users" WHERE "users"."name" = $1 ORDER BY users.id ASC  [["name", 'mike']]

User.exists?(name: 'mike')
# User Exists (2.4ms)  SELECT 1 AS one FROM "users" WHERE "users"."name" = $1 ORDER BY users.id ASC LIMIT 1  [["name", 'mike']]
# 如果是any? 1 AS one的部分會變成COUNT(*)

class User < ActiveRecord::Base
  has_many :clients
end

class Client < ActiveRecord::Base
  has_many :contacts
  belongs_to :user
end
class Contact < ActiveRecord::Base
  belongs_to :client
end

@contacts = @user.clients.includes( :contact )

class Post < ActiveRecord::Base
  has_many :comments
  belongs_to :user
end

class Comment < ActiveRecord::Base
  has_many :replies
  belongs_to :user
end

class Reply < ActiveRecord::Base
  belongs_to :user
end

class User < ActiveRecord::Base
  has_many :posts
  has_many :comments
  has_many :replies
end

# 不包含user
Post.includes(:comments => [:replies])

# 包含user
Post.includes(:user, :comments= > [:user, {:replies => [:user]}])

order = FactoryBot.create(
  :order,
  line_items: [FactoryBot.create(:line_item, price_cents: 40000)],
  payments: [FactoryBot.create(:payment, amount_cents: 40000)]
)

# orders.yml
payments_equal_line_item_total:
  # no attributes needed

# line_items.yml
electric_dog_polisher:
  order: payments_equal_line_item_total
  name: 'Electric dog polisher'
  price_cents: 40000

# payment_methods.yml
visa:
  name: 'Visa'

# payments.yml
first:
  order: payments_equal_line_item_total
  payment_method: visa
  amount_cents: 40000

# order = orders(:payments_equal_line_item_total)

arr # events_path, GET
arr[i] # event_path(@event), GET
arr << "something" # events_path, POST
arr.delete(i) # event_path(@event), DELETE
arr.update(i, "something") # event_path(@event), PATCH/PUT