Есть несколько проблем с каждым из доступных методов, но я считаю, что определение обратного вызова after_initialize - это правильный путь по следующим причинам:

1. default_scope инициализирует значения для новых моделей, но затем это станет областью, в которой вы найдете модель. Если вы просто хотите инициализировать некоторые числа до 0, тогда это не то, что вам нужно.
2. Определение значений по умолчанию в вашей миграции также работает некоторое время ... Как уже упоминалось, это не сработает, когда вы просто вызовете Model.new.
3. Переопределение initialize может работать, но не забудьте позвонить super!
4. Использование такого плагина, как phusion, становится немного смешным. Это рубин, действительно ли нам нужен плагин для инициализации некоторых значений по умолчанию?
5. Переопределение after_initialize устарело в Rails 3. Когда я переопределяю after_initialize в rails 3.0.3, я получаю следующее предупреждение в консоли:

ПРЕДУПРЕЖДЕНИЕ ОБ УСТАРЕВАНИИ: Base # after_initialize устарел, используйте вместо него метод Base.after_initialize :. (вызывается из / Users / me / myapp / app / models / my_model: 15)

Поэтому я бы посоветовал написать обратный вызов after_initialize, который позволяет вам использовать атрибуты по умолчанию в дополнение к, позволяя вам устанавливать значения по умолчанию для таких ассоциаций:

  class Person < ActiveRecord::Base
    has_one :address
    after_initialize :init

    def init
      self.number  ||= 0.0           #will set the default value only if it's nil
      self.address ||= build_address #let's you set a default association
    end
  end    

Теперь у вас есть только одно место для поиска инициализации ваших моделей. Я использую этот метод, пока кто-нибудь не придумает лучший.

Предостережения:

1. Для логических полей выполните:

   self.bool_field = true if self.bool_field.nil?

   См. Комментарий Пола Рассела к этому ответу для получения более подробной информации.

2. Если вы выбираете только подмножество столбцов для модели (т. Е. Используете select в запросе типа Person.select(:firstname, :lastname).all), вы получите MissingAttributeError, если ваш метод init обращается к столбцу, который не был включен в предложение select. Вы можете защититься от этого случая так:

   self.number ||= 0.0 if self.has_attribute? :number

   а для логического столбца ...

   self.bool_field = true if (self.has_attribute? :bool_value) && self.bool_field.nil?

   Также обратите внимание, что синтаксис отличался до Rails 3.2 (см. Комментарий Клиффа Дарлинга ниже)

Рельсы 5+

Вы можете использовать в своих моделях метод attribute , например:

class Account < ApplicationRecord
  attribute :locale, :string, default: 'en'
end

Вы также можете передать лямбду параметру default. Пример:

attribute :uuid, :string, default: -> { SecureRandom.uuid }

Второй аргумент - это тип, и он также может быть экземпляром класса настраиваемого типа, например:

attribute :uuid, UuidType.new, default: -> { SecureRandom.uuid }

Мы помещаем значения по умолчанию в базу данных посредством миграции (путем указания параметра :default в каждом определении столбца) и позволяем Active Record использовать эти значения для установки значения по умолчанию для каждого атрибута.

IMHO, этот подход согласуется с принципами AR: соглашение важнее конфигурации, DRY, определение таблицы управляет моделью, а не наоборот.

Обратите внимание, что значения по умолчанию все еще находятся в коде приложения (Ruby), но не в модели, а в миграции (ах).

Некоторые простые случаи могут быть обработаны путем определения значения по умолчанию в схеме базы данных, но это не обрабатывает ряд более сложных случаев, включая вычисленные значения и ключи других моделей. Для этих случаев я делаю так:

after_initialize :defaults

def defaults
   unless persisted?
    self.extras||={}
    self.other_stuff||="This stuff"
    self.assoc = [OtherModel.find_by_name('special')]
  end
end

Я решил использовать after_initialize, но не хочу, чтобы он применялся к объектам, которые обнаруживаются только новыми или созданными. Я думаю, что это почти шокирует, что обратный вызов after_new не предусмотрен для этого очевидного варианта использования, но я сделал это, подтвердив, сохраняется ли объект уже, указывая, что он не новый.

Увидев ответ Брэда Мюррея, он станет еще чище, если переместить условие в запрос обратного вызова:

after_initialize :defaults, unless: :persisted?
              # ":if => :new_record?" is equivalent in this context

def defaults
  self.extras||={}
  self.other_stuff||="This stuff"
  self.assoc = [OtherModel.find_by_name('special')]
end

Шаблон обратного вызова after_initialize можно улучшить, просто выполнив следующие действия.

after_initialize :some_method_goes_here, :if => :new_record?

Это дает нетривиальное преимущество, если ваш код инициализации должен иметь дело с ассоциациями, поскольку следующий код запускает тонкий n + 1, если вы читаете начальную запись без включения связанной.

class Account

  has_one :config
  after_initialize :init_config

  def init_config
    self.config ||= build_config
  end

end

У ребят из Phusion есть хороший плагин для этого.

Еще лучший / более чистый потенциальный способ, чем предложенные ответы, - это перезаписать аксессор, например:

def status
  self['status'] || ACTIVE
end

См. «Перезапись средств доступа по умолчанию» в документации ActiveRecord :: Base и больше из StackOverflow об использовании себя.

Я использую attribute-defaults gem

Из документации: запустите sudo gem install attribute-defaults и добавьте require 'attribute_defaults' в свое приложение.

class Foo < ActiveRecord::Base
  attr_default :age, 18
  attr_default :last_seen do
    Time.now
  end
end

Foo.new()           # => age: 18, last_seen => "2014-10-17 09:44:27"
Foo.new(:age => 25) # => age: 25, last_seen => "2014-10-17 09:44:28"

Похожие вопросы, но все имеют немного другой контекст: - Как мне создать значение по умолчанию для атрибутов в модели Rails activerecord?

Лучший ответ: Зависит от того, чего вы хотите!

Если вы хотите, чтобы каждый объект начинался со значения: используйте after_initialize :init

Вы хотите, чтобы форма new.html имела значение по умолчанию при открытии страницы? используйте https://stackoverflow.com/a/5127684/1536309

class Person < ActiveRecord::Base
  has_one :address
  after_initialize :init

  def init
    self.number  ||= 0.0           #will set the default value only if it's nil
    self.address ||= build_address #let's you set a default association
  end
  ...
end 

Если вы хотите, чтобы каждый объект имел значение, вычисленное на основе пользовательского ввода: используйте before_save :default_values. Вы хотите, чтобы пользователь ввел X, а затем Y = X+'foo'? использовать:

class Task < ActiveRecord::Base
  before_save :default_values
  def default_values
    self.status ||= 'P'
  end
end

Я также видел, как люди добавляли его в свою миграцию, но я бы предпочел, чтобы он был определен в коде модели.

Есть ли канонический способ установить значение по умолчанию для полей в модели ActiveRecord?

Канонический способ Rails до Rails 5 состоял в том, чтобы установить его при миграции и просто смотреть в db/schema.rb всякий раз, когда вы хотите увидеть, какие значения по умолчанию устанавливаются БД для любой модели.

Вопреки тому, что указано в ответе @Jeff Perrin (что немного устарело), ​​подход к миграции даже применит значение по умолчанию при использовании Model.new из-за некоторой магии Rails. Проверена работа в Rails 4.1.16.

Самое простое часто бывает лучшим. Меньше долга знаний и потенциальных точек путаницы в кодовой базе. И это «просто работает».

class AddStatusToItem < ActiveRecord::Migration
  def change
    add_column :items, :scheduler_type, :string, { null: false, default: "hotseat" }
  end
end

Или, для изменения столбца без создания нового, выполните одно из следующих действий:

class AddStatusToItem < ActiveRecord::Migration
  def change
    change_column_default :items, :scheduler_type, "hotseat"
  end
end

Или, может быть, даже лучше:

class AddStatusToItem < ActiveRecord::Migration
  def change
    change_column :items, :scheduler_type, :string, default: "hotseat"
  end
end

Обратитесь к официальному руководству RoR, чтобы узнать о вариантах методов изменения столбцов.

null: false запрещает значения NULL в БД, и, в качестве дополнительного преимущества, он также обновляется, так что для всех ранее существовавших записей БД, которые ранее были нулевыми, также устанавливается значение по умолчанию для этого поля. Вы можете исключить этот параметр из миграции, если хотите, но мне это очень удобно!

Канонический способ в Rails 5+, как сказал @Lucas Caton:

class Item < ActiveRecord::Base
  attribute :scheduler_type, :string, default: 'hotseat'
end

Вот для чего нужны конструкторы! Переопределить метод initialize модели.

Используйте метод after_initialize.

Привет, ребята, в итоге я сделал следующее:

def after_initialize 
 self.extras||={}
 self.other_stuff||="This stuff"
end

Работает как шарм!

На этот вопрос уже давно ответили, но мне часто нужны значения по умолчанию, и я предпочитаю не помещать их в базу данных. Я создаю DefaultValues беспокойство:

module DefaultValues
  extend ActiveSupport::Concern

  class_methods do
    def defaults(attr, to: nil, on: :initialize)
      method_name = "set_default_#{attr}"
      send "after_#{on}", method_name.to_sym

      define_method(method_name) do
        if send(attr)
          send(attr)
        else
          value = to.is_a?(Proc) ? to.call : to
          send("#{attr}=", value)
        end
      end

      private method_name
    end
  end
end

А затем использовать его в моих моделях так:

class Widget < ApplicationRecord
  include DefaultValues

  defaults :category, to: 'uncategorized'
  defaults :token, to: -> { SecureRandom.uuid }
end

Я столкнулся с проблемами, когда after_initialize выдавал ActiveModel::MissingAttributeError ошибки при выполнении сложных поисков:

eg:

@bottles = Bottle.includes(:supplier, :substance).where(search).order("suppliers.name ASC").paginate(:page => page_no)

"поиск" в .where - это хеш условий

В итоге я сделал это, переопределив инициализацию следующим образом:

def initialize
  super
  default_values
end

private
 def default_values
     self.date_received ||= Date.current
 end

Вызов super необходим, чтобы убедиться, что объект правильно инициализируется из ActiveRecord::Base перед выполнением моего кода настройки, то есть: default_values

after_initialize устарел, используйте вместо него обратный вызов.

after_initialize :defaults

def defaults
  self.extras||={}
  self.other_stuff||="This stuff"
end

однако использование : default при переносе по-прежнему является самым чистым способом.

Проблема с решениями after_initialize заключается в том, что вам нужно добавить after_initialize к каждому отдельному объекту, который вы ищете из БД, независимо от того, получаете ли вы доступ к этому атрибуту или нет. Я предлагаю ленивый подход.

Методы атрибутов (геттеры), конечно же, сами являются методами, поэтому вы можете переопределить их и указать значение по умолчанию. Что-то вроде:

Class Foo < ActiveRecord::Base
  # has a DB column/field atttribute called 'status'
  def status
    (val = read_attribute(:status)).nil? ? 'ACTIVE' : val
  end
end

Если, как кто-то указал, вам нужно выполнить Foo.find_by_status ('ACTIVE'). В этом случае я думаю, вам действительно нужно установить ограничения по умолчанию в вашей базе данных, если БД поддерживает это.

Я настоятельно рекомендую использовать драгоценный камень default_value_for: https://github.com/FooBarWidget/default_value_for

Есть несколько сложных сценариев, которые в значительной степени требуют переопределения метода инициализации, что и делает этот гем.

Примеры:

По умолчанию для вашей базы данных установлено значение NULL, по умолчанию для вашей модели / рубина является "некоторая строка", но на самом деле вы хотите установить значение nil по любой причине: MyModel.new(my_attr: nil)

В большинстве решений здесь не будет установлено значение nil, вместо этого будет установлено значение по умолчанию.

Хорошо, поэтому вместо подхода ||= вы переключаетесь на _3 _...

НО теперь представьте, что ваша база данных по умолчанию - это "некоторая строка", по умолчанию ваша модель / рубин - "некоторая другая строка", но при определенном сценарии вы хотите установить значение "некоторая строка" (по умолчанию db): MyModel.new(my_attr: 'some_string')

Это приведет к тому, что my_attr_changed? будет ложным, потому что значение соответствует значению по умолчанию в базе данных, что, в свою очередь, запустит ваш определяемый рубином код по умолчанию и установит значение "какая-то другая строка" - опять же, не то, что вы желанный.

По этим причинам я не думаю, что этого можно сделать должным образом с помощью хука after_initialize.

Опять же, я думаю, что гем "default_value_for" использует правильный подход: https://github.com/FooBarWidget/default_value_for < / а>

Хотя это для установки значений по умолчанию в большинстве случаев сбивает с толку и неудобно, вы также можете использовать :default_scope. Ознакомьтесь с комментарием squil здесь.

Я обнаружил, что использование метода проверки дает большой контроль над установкой значений по умолчанию. Вы даже можете установить значения по умолчанию (или не пройти проверку) для обновлений. Вы даже можете установить другое значение по умолчанию для вставок и обновлений, если действительно хотите. Обратите внимание, что значение по умолчанию не будет установлено до #valid? называется.

class MyModel
  validate :init_defaults

  private
  def init_defaults
    if new_record?
      self.some_int ||= 1
    elsif some_int.nil?
      errors.add(:some_int, "can't be blank on update")
    end
  end
end

Что касается определения метода after_initialize, могут возникнуть проблемы с производительностью, потому что after_initialize также вызывается каждым объектом, возвращаемым: find: http://guides.rubyonrails.org/active_record_validations_callbacks.html#after_initialize-and-after_find

Если столбец является столбцом типа «статус», а ваша модель допускает использование конечных автоматов, рассмотрите возможность использования aasm gem, после чего вы можете просто сделать

  aasm column: "status" do
    state :available, initial: true
    state :used
    # transitions
  end

Он по-прежнему не инициализирует значение для несохраненных записей, но он немного чище, чем использование собственного с init или чем-то еще, и вы получаете другие преимущества aasm, такие как области для всех ваших статусов.

https://github.com/keithrowell/rails_default_value

class Task < ActiveRecord::Base
  default :status => 'active'
end

Вот решение, которое я использовал и которое, как я был немного удивлен, еще не было добавлено.

Он состоит из двух частей. Первая часть устанавливает значение по умолчанию в фактической миграции, а вторая часть добавляет проверку в модель, гарантирующую, что присутствие истинно.

add_column :teams, :new_team_signature, :string, default: 'Welcome to the Team'

Здесь вы увидите, что значение по умолчанию уже установлено. Теперь при проверке вы хотите убедиться, что для строки всегда есть значение, поэтому просто выполните

 validates :new_team_signature, presence: true

Это позволит установить для вас значение по умолчанию. (для меня у меня есть «Добро пожаловать в команду»), а затем он сделает еще один шаг, чтобы гарантировать, что для этого объекта всегда присутствует значение.

Надеюсь, это поможет!

У меня была аналогичная проблема, когда я работал над приложением Rails 6.

Вот как я это решил:

У меня есть таблица Users и таблица Roles. Таблица Users принадлежит таблице Roles. У меня также есть модели Admin и Student, которые наследуются от таблицы Users.

Затем потребовалось, чтобы я устанавливал значение по умолчанию для роли всякий раз, когда создается пользователь, скажем, admin роль, которая имеет роль id = 1 или student, которая имеет id = 2.

class User::Admin < User
  before_save :default_values

  def default_values
    # set role_id to '1' except if role_id is not empty
    return self.role_id = '1' unless role_id.nil?
  end
end

Это означает, что до того, как admin пользователь будет создан / сохранен в базе данных, role_id устанавливается на значение по умолчанию 1, если он не пуст.

return self.role_id = '1' unless role_id.nil? 

такой же как:

return self.role_id = '1' unless self.role_id.nil?

и так же, как:

self.role_id = '1' if role_id.nil?

но первый чище и точнее.

Это все.

Надеюсь, это поможет

Пользуюсь этим какое-то время.

# post.rb
class Post < ApplicationRecord
  attribute :country, :string, default: 'ID'
end

используйте default_scope в рельсах 3

api doc

ActiveRecord скрывает разницу между значением по умолчанию, определенным в базе данных (схеме), и значением по умолчанию, выполненным в приложении (модели). Во время инициализации он анализирует схему базы данных и отмечает все указанные в ней значения по умолчанию. Позже, при создании объектов, он назначает эти значения по умолчанию, указанные в схеме, не касаясь базы данных.

обсуждение

Из документации api http://api.rubyonrails.org/classes/ActiveRecord/Callbacks.html Используйте метод before_validation в своей модели, он дает вам возможность создать конкретную инициализацию для вызовов create и update, например в этом примере (снова код, взятый из примера api docs) числовое поле инициализируется для кредитной карты. Вы можете легко настроить это, чтобы установить любые значения, которые вы хотите

class CreditCard < ActiveRecord::Base
  # Strip everything but digits, so the user can specify "555 234 34" or
  # "5552-3434" or both will mean "55523434"
  before_validation(:on => :create) do
    self.number = number.gsub(%r[^0-9]/, "") if attribute_present?("number")
  end
end

class Subscription < ActiveRecord::Base
  before_create :record_signup

  private
    def record_signup
      self.signed_up_on = Date.today
    end
end

class Firm < ActiveRecord::Base
  # Destroys the associated clients and people when the firm is destroyed
  before_destroy { |record| Person.destroy_all "firm_id = #{record.id}"   }
  before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
end

Удивлен, что его здесь не предложили