1 如何加載核心擴展

1.1 獨立的 Active Support

為了使默認的佔用空間最小，Active Support 默認只加載最少的依賴項。它被拆分成小塊，以便只加載所需的擴展。它還提供了一些方便的入口點，以一次性加載相關的擴展，甚至是全部。

因此，只需簡單的 require：

require "active_support"

只會加載 Active Support 框架所需的擴展。

1.1.1 挑選定義

以下示例演示了如何加載 Hash#with_indifferent_access。該擴展使得可以將 Hash 轉換為 ActiveSupport::HashWithIndifferentAccess，從而可以使用字符串或符號作為鍵。

{ a: 1 }.with_indifferent_access["a"] # => 1

對於每個定義為核心擴展的方法，本指南都有一個說明該方法定義在哪裡的註釋。對於 with_indifferent_access，註釋如下：

注意：定義在 active_support/core_ext/hash/indifferent_access.rb 中。

這意味著您可以這樣 require：

require "active_support"
require "active_support/core_ext/hash/indifferent_access"

Active Support 經過精心修訂，因此挑選一個文件只會加載嚴格需要的依賴項（如果有的話）。

1.1.2 加載分組的核心擴展

下一級是只需加載所有 Hash 的擴展。作為一個經驗法則，對於 SomeClass 的擴展可以通過加載 active_support/core_ext/some_class 一次性加載。

因此，要加載所有 Hash 的擴展（包括 with_indifferent_access）：

require "active_support"
require "active_support/core_ext/hash"

1.1.3 加載所有核心擴展

您可能只想加載所有核心擴展，有一個文件可以實現：

require "active_support"
require "active_support/core_ext"

1.1.4 加載所有 Active Support

最後，如果您想要加載所有 Active Support，只需執行以下操作：

require "active_support/all"

實際上，這甚至不會將整個 Active Support 預先加載到內存中，一些內容是通過 autoload 配置的，只有在使用時才會加載。

1.2 在 Ruby on Rails 應用程序中使用 Active Support

Ruby on Rails 應用程序會加載所有 Active Support，除非 config.active_support.bare 為 true。在這種情況下，應用程序只會加載框架本身為自己需要的內容進行挑選，並且仍然可以按照前一節中的說明進行任意細粒度的挑選。

2 對所有對象的擴展

2.1 `blank?` 和 `present?`

在 Rails 應用程序中，以下值被視為空白：

nil 和 false，
只包含空白字符的字符串（請參閱下面的註釋），
空數組和哈希，以及
任何其他對象，如果該對象響應 empty? 並且為空。

字符串的判斷使用了支持 Unicode 的字符類 [:space:]，因此例如 U+2029（段落分隔符）被視為空白字符。警告：請注意，文中未提及數字。特別是，0 和 0.0 不是空白。

例如，ActionController::HttpAuthentication::Token::ControllerMethods 中的這個方法使用 blank? 檢查令牌是否存在：

def authenticate(controller, &login_procedure)
  token, options = token_and_options(controller.request)
  unless token.blank?
    login_procedure.call(token, options)
  end
end

present? 方法等同於 !blank?。這個例子來自 ActionDispatch::Http::Cache::Response：

def set_conditional_cache_control!
  return if self["Cache-Control"].present?
  # ...
end

注意：定義在 active_support/core_ext/object/blank.rb 中。

2.2 `presence`

presence 方法如果 present? 則返回接收者本身，否則返回 nil。這在以下情況下很有用：

host = config[:host].presence || 'localhost'

注意：定義在 active_support/core_ext/object/blank.rb 中。

2.3 `duplicable?`

從 Ruby 2.5 開始，大多數對象都可以通過 dup 或 clone 進行複製：

"foo".dup           # => "foo"
"".dup              # => ""
Rational(1).dup     # => (1/1)
Complex(0).dup      # => (0+0i)
1.method(:+).dup    # => TypeError (allocator undefined for Method)

Active Support 提供 duplicable? 來查詢對象是否可複製：

"foo".duplicable?           # => true
"".duplicable?              # => true
Rational(1).duplicable?     # => true
Complex(1).duplicable?      # => true
1.method(:+).duplicable?    # => false

警告：任何類都可以通過刪除 dup 和 clone 或從中引發異常來禁止複製。因此，只有 rescue 可以告訴您給定的任意對象是否可複製。duplicable? 依賴於上面的硬編碼列表，但它比 rescue 快得多。只有在您知道硬編碼列表在您的用例中足夠時才使用它。

注意：定義在 active_support/core_ext/object/duplicable.rb 中。

2.4 `deep_dup`

deep_dup 方法返回給定對象的深度副本。通常，當您對包含其他對象的對象進行 dup 時，Ruby 不會對它們進行 dup，因此它創建了對象的淺層副本。例如，如果您有一個包含字符串的數組，它會像這樣：

array     = ['string']
duplicate = array.dup

duplicate.push 'another-string'

# 對象已複製，因此元素僅添加到副本中
array     # => ['string']
duplicate # => ['string', 'another-string']

duplicate.first.gsub!('string', 'foo')

# 第一個元素未複製，它將在兩個數組中更改
array     # => ['foo']
duplicate # => ['foo', 'another-string']

如您所見，在複製 Array 實例之後，我們得到了另一個對象，因此我們可以修改它，而原始對象將保持不變。但是，對於數組的元素來說，情況並非如此。由於 dup 不進行深度複製，數組內部的字符串仍然是同一個對象。

如果您需要對象的深度副本，應該使用 deep_dup。這是一個例子：

array     = ['string']
duplicate = array.deep_dup

duplicate.first.gsub!('string', 'foo')

array     # => ['string']
duplicate # => ['foo']

如果對象不可複製，deep_dup 將返回它本身：

number = 1
duplicate = number.deep_dup
number.object_id == duplicate.object_id   # => true

注意：定義在 active_support/core_ext/object/deep_dup.rb 中。

2.5 `try`

當您只想在對象不為 nil 時調用一個方法時，最簡單的方法是使用條件語句，這會增加不必要的雜亂。另一種方法是使用 try。try 類似於 Object#public_send，但如果發送給 nil，它會返回 nil。以下是一個例子：

# 沒有使用 try
unless @number.nil?
  @number.next
end

# 使用 try
@number.try(:next)

另一個例子是來自 ActiveRecord::ConnectionAdapters::AbstractAdapter 的程式碼，其中 @logger 可能為 nil。你可以看到程式碼使用了 try 並避免了不必要的檢查。

def log_info(sql, name, ms)
  if @logger.try(:debug?)
    name = '%s (%.1fms)' % [name || 'SQL', ms]
    @logger.debug(format_log_entry(name, sql.squeeze(' ')))
  end
end

try 也可以在沒有參數但有區塊的情況下呼叫，只有在物件不為 nil 時才會執行該區塊：

@person.try { |p| "#{p.first_name} #{p.last_name}" }

請注意，try 會吞掉不存在的方法錯誤，並返回 nil。如果你想要防止拼寫錯誤，可以使用 try!：

@number.try(:nest)  # => nil
@number.try!(:nest) # NoMethodError: undefined method `nest' for 1:Integer

注意：try 定義在 active_support/core_ext/object/try.rb 中。

2.6 `class_eval(*args, &block)`

你可以使用 class_eval 在任何物件的單例類別中評估程式碼：

class Proc
  def bind(object)
    block, time = self, Time.current
    object.class_eval do
      method_name = "__bind_#{time.to_i}_#{time.usec}"
      define_method(method_name, &block)
      method = instance_method(method_name)
      remove_method(method_name)
      method
    end.bind(object)
  end
end

注意：class_eval 定義在 active_support/core_ext/kernel/singleton_class.rb 中。

2.7 `acts_like?(duck)`

acts_like? 方法提供了一種檢查某個類別是否像另一個類別一樣的方式，基於一個簡單的約定：一個提供與 String 相同介面的類別定義了

def acts_like_string?
end

這只是一個標記，它的內容或返回值都不重要。然後，客戶端程式碼可以這樣查詢是否符合鴨子類型：

some_klass.acts_like?(:string)

Rails 中有一些類別像 Date 或 Time 並遵循這個約定。

注意：acts_like? 定義在 active_support/core_ext/object/acts_like.rb 中。

2.8 `to_param`

Rails 中的所有物件都會回應 to_param 方法，該方法用於返回一個代表它們作為查詢字串或 URL 片段的值。

預設情況下，to_param 只會呼叫 to_s：

7.to_param # => "7"

to_param 的返回值不應該被轉義：

"Tom & Jerry".to_param # => "Tom & Jerry"

Rails 中的幾個類別會覆寫這個方法。

例如，nil、true 和 false 會返回它們自己。Array#to_param 會對元素調用 to_param，並使用 "/" 將結果連接起來：

[0, true, String].to_param # => "0/true/String"

值得注意的是，Rails 的路由系統會對模型調用 to_param 以獲取 :id 佔位符的值。ActiveRecord::Base#to_param 返回模型的 id，但你可以在你的模型中重新定義該方法。例如，假設有以下定義：

class User
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

我們可以得到：

user_path(@user) # => "/users/357-john-smith"

警告：控制器需要注意 to_param 的重新定義，因為當像這樣的請求進來時，"357-john-smith" 是 params[:id] 的值。

注意：to_param 定義在 active_support/core_ext/object/to_param.rb 中。

2.9 `to_query`

to_query 方法構造一個查詢字串，將給定的 key 與 to_param 的返回值關聯起來。例如，有以下 to_param 定義：

class User
  def to_param
    "#{id}-#{name.parameterize}"
  end
end

我們可以得到：

current_user.to_query('user') # => "user=357-john-smith"

該方法會對需要的內容進行轉義，包括鍵和值：

account.to_query('company[name]')
# => "company%5Bname%5D=Johnson+%26+Johnson"

因此，它的輸出已經可以在查詢字串中使用。陣列返回將每個元素應用to_query的結果，並使用key[]作為鍵，將結果連接起來，中間用"&"分隔：

[3.4, -45.6].to_query('sample')
# => "sample%5B%5D=3.4&sample%5B%5D=-45.6"

哈希也可以使用to_query，但使用不同的參數。如果沒有傳遞參數，則會生成一系列按鍵/值分配的排序結果，並在其值上調用to_query(key)。然後將結果用"&"連接起來：

{ c: 3, b: 2, a: 1 }.to_query # => "a=1&b=2&c=3"

方法Hash#to_query接受可選的命名空間作為鍵：

{ id: 89, name: "John Smith" }.to_query('user')
# => "user%5Bid%5D=89&user%5Bname%5D=John+Smith"

注意：定義在active_support/core_ext/object/to_query.rb中。

2.10 `with_options`

方法with_options提供了一種在一系列方法調用中提取公共選項的方式。

給定一個默認的選項哈希，with_options會將一個代理對象傳遞給塊。在塊內，對代理調用的方法將與其選項合併後轉發給接收者。例如，你可以通過以下方式消除重複：

class Account < ApplicationRecord
  has_many :customers, dependent: :destroy
  has_many :products,  dependent: :destroy
  has_many :invoices,  dependent: :destroy
  has_many :expenses,  dependent: :destroy
end

改為：

class Account < ApplicationRecord
  with_options dependent: :destroy do |assoc|
    assoc.has_many :customers
    assoc.has_many :products
    assoc.has_many :invoices
    assoc.has_many :expenses
  end
end

這種用法也可以傳達給讀者的“分組”意圖。例如，假設你想要發送一封新聞通訊，其語言取決於用戶。你可以在郵件程序的某個地方像這樣分組依賴於語言的部分：

I18n.with_options locale: user.locale, scope: "newsletter" do |i18n|
  subject i18n.t :subject
  body    i18n.t :body, user_name: user.name
end

提示：由於with_options將調用轉發給其接收者，因此可以進行嵌套。每個嵌套級別都將合併繼承的默認值以及自己的默認值。

注意：定義在active_support/core_ext/object/with_options.rb中。

2.11 JSON支持

Active Support提供了比Ruby對象通常提供的json gem更好的to_json實現。這是因為一些類，如Hash和Process::Status，需要特殊處理才能提供正確的JSON表示。

注意：定義在active_support/core_ext/object/json.rb中。

2.12 實例變量

Active Support提供了幾個方法來方便訪問實例變量。

2.12.1 `instance_values`

方法instance_values返回一個將實例變量名（不包含“@”）映射到其對應值的哈希。鍵是字符串：

class C
  def initialize(x, y)
    @x, @y = x, y
  end
end

C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}

注意：定義在active_support/core_ext/object/instance_variables.rb中。

2.12.2 `instance_variable_names`

方法instance_variable_names返回一個數組。每個名稱都包含“@”符號。

class C
  def initialize(x, y)
    @x, @y = x, y
  end
end

C.new(0, 1).instance_variable_names # => ["@x", "@y"]

注意：定義在active_support/core_ext/object/instance_variables.rb中。

2.13 禁止警告和異常

方法silence_warnings和enable_warnings會在其塊的執行期間相應地更改$VERBOSE的值，並在之後重置它：

silence_warnings { Object.const_set "RAILS_DEFAULT_LOGGER", logger }

使用suppress也可以禁止異常。此方法接收任意數量的異常類。如果在塊的執行過程中引發了異常並且kind_of?任何參數的類型，則suppress會捕獲它並靜默返回。否則，異常不會被捕獲： ```ruby

如果使用者被鎖定，增量將會遺失，不會有太大問題。

suppress(ActiveRecord::StaleObjectError) do current_user.increment! :visits end ```

注意：定義在 active_support/core_ext/kernel/reporting.rb 中。

2.14 `in?`

謂詞 in? 測試一個物件是否包含在另一個物件中。如果傳遞的參數不回應 include?，則會引發 ArgumentError 例外。

in? 的範例：

1.in?([1, 2])        # => true
"lo".in?("hello")   # => true
25.in?(30..50)      # => false
1.in?(1)            # => ArgumentError

注意：定義在 active_support/core_ext/object/inclusion.rb 中。

3 `Module` 的擴充

3.1 屬性

3.1.1 `alias_attribute`

模型屬性具有讀取器、寫入器和謂詞。你可以使用 alias_attribute 為模型屬性建立對應的三個方法的別名。與其他別名方法一樣，新名稱是第一個參數，舊名稱是第二個參數（一個助記法是它們的順序與賦值相同）：

class User < ApplicationRecord
  # 你可以將 email 欄位稱為 "login"。
  # 對於身份驗證代碼來說，這可能有意義。
  alias_attribute :login, :email
end

注意：定義在 active_support/core_ext/module/aliasing.rb 中。

3.1.2 內部屬性

當你在一個預計被子類化的類中定義屬性時，名稱衝突是一個風險。這對於庫來說非常重要。

Active Support 定義了宏 attr_internal_reader、attr_internal_writer 和 attr_internal_accessor。它們的行為與 Ruby 內建的 attr_* 相同，只是它們以一種使衝突更少可能的方式命名底層實例變數。

宏 attr_internal 是 attr_internal_accessor 的同義詞：

# 库
class ThirdPartyLibrary::Crawler
  attr_internal :log_level
end

# 客戶端代碼
class MyCrawler < ThirdPartyLibrary::Crawler
  attr_accessor :log_level
end

在上面的例子中，:log_level 可能不屬於庫的公共接口，只在開發中使用。客戶端代碼不知道潛在的衝突，子類化並定義了自己的 :log_level。由於 attr_internal，沒有衝突。

默認情況下，內部實例變數以下劃線開頭命名，例如上面的例子中的 @_log_level。這可以通過 Module.attr_internal_naming_format 進行配置，你可以傳遞任何具有前導 @ 和某處包含名稱的 %s 的 sprintf-like 格式字符串，名稱將放在那裡。默認值為 "@_%s"。

Rails 在一些地方使用內部屬性，例如視圖：

module ActionView
  class Base
    attr_internal :captures
    attr_internal :request, :layout
    attr_internal :controller, :template
  end
end

注意：定義在 active_support/core_ext/module/attr_internal.rb 中。

3.1.3 模組屬性

宏 mattr_reader、mattr_writer 和 mattr_accessor 與為類定義的 cattr_* 宏相同。實際上，cattr_* 宏只是 mattr_* 宏的別名。請參閱類屬性。

例如，Active Storage 的日誌記錄器 API 是使用 mattr_accessor 生成的：

module ActiveStorage
  mattr_accessor :logger
end

注意：定義在 active_support/core_ext/module/attribute_accessors.rb 中。

3.2 父模組

3.2.1 `module_parent`

嵌套命名模組上的 module_parent 方法返回包含其對應常量的模組：

module X
  module Y
    module Z
    end
  end
end
M = X::Y::Z

X::Y::Z.module_parent # => X::Y
M.module_parent       # => X::Y

如果模組是匿名的或屬於頂層，module_parent 返回 Object。警告：請注意，在這種情況下，module_parent_name 返回 nil。

注意：定義於 active_support/core_ext/module/introspection.rb。

3.2.2 `module_parent_name`

在嵌套命名模組上，module_parent_name 方法返回包含對應常數的模組的完全限定名稱：

module X
  module Y
    module Z
    end
  end
end
M = X::Y::Z

X::Y::Z.module_parent_name # => "X::Y"
M.module_parent_name       # => "X::Y"

對於頂層或匿名模組，module_parent_name 返回 nil。

警告：請注意，在這種情況下，module_parent 返回 Object。

注意：定義於 active_support/core_ext/module/introspection.rb。

3.2.3 `module_parents`

module_parents 方法在接收者上調用 module_parent，直到達到 Object。鏈將以陣列形式從底部到頂部返回：

module X
  module Y
    module Z
    end
  end
end
M = X::Y::Z

X::Y::Z.module_parents # => [X::Y, X, Object]
M.module_parents       # => [X::Y, X, Object]

注意：定義於 active_support/core_ext/module/introspection.rb。

3.3 匿名模組

模組可能有或沒有名稱：

module M
end
M.name # => "M"

N = Module.new
N.name # => "N"

Module.new.name # => nil

您可以使用預測方法 anonymous? 檢查模組是否有名稱：

module M
end
M.anonymous? # => false

Module.new.anonymous? # => true

請注意，無法訪問並不意味著是匿名的：

module M
end

m = Object.send(:remove_const, :M)

m.anonymous? # => false

儘管如此，根據定義，匿名模組是無法訪問的。

注意：定義於 active_support/core_ext/module/anonymous.rb。

3.4 方法委派

3.4.1 `delegate`

宏 delegate 提供了一種簡單的方法來轉發方法。

假設某個應用程序中的用戶在 User 模型中具有登錄信息，但在單獨的 Profile 模型中具有名稱和其他數據：

class User < ApplicationRecord
  has_one :profile
end

使用該配置，您可以通過用戶的配置文件獲取用戶的名稱，user.profile.name，但仍然可以直接訪問該屬性可能很方便：

class User < ApplicationRecord
  has_one :profile

  def name
    profile.name
  end
end

這就是 delegate 為您做的事情：

class User < ApplicationRecord
  has_one :profile

  delegate :name, to: :profile
end

這樣更簡潔，意圖更明顯。

目標中的方法必須是公開的。

delegate 宏接受多個方法：

delegate :name, :age, :address, :twitter, to: :profile

當插入到字符串中時，:to 選項應該變成一個求值為方法委派對象的表達式。通常是一個字符串或符號。這樣的表達式在接收者的上下文中求值：

# 委派給 Rails 常數
delegate :logger, to: :Rails

# 委派給接收者的類
delegate :table_name, to: :class

警告：如果 :prefix 選項為 true，則這就不那麼通用，請參見下文。

默認情況下，如果委派引發 NoMethodError，並且目標為 nil，則異常將被傳播。您可以使用 :allow_nil 選項要求返回 nil：

delegate :name, to: :profile, allow_nil: true

使用 :allow_nil，如果用戶沒有配置文件，則調用 user.name 將返回 nil。

選項 :prefix 將前綴添加到生成方法的名稱。這可能很方便，例如獲得更好的名稱： ruby delegate :street, to: :address, prefix: true

前面的例子生成的是address_street而不是street。

警告：由於在這種情況下，生成的方法名由目標對象和目標方法名組成，所以:to選項必須是一個方法名。

也可以配置自定義的前綴：

delegate :size, to: :attachment, prefix: :avatar

在前面的例子中，宏生成的是avatar_size而不是size。

選項:private可以改變方法的作用域：

delegate :date_of_birth, to: :profile, private: true

委託的方法默認是公開的。傳遞private: true以更改這一點。

注意：定義在active_support/core_ext/module/delegation.rb中

3.4.2 `delegate_missing_to`

假設您希望將User對象中缺少的所有內容委託給Profile對象。delegate_missing_to宏讓您可以輕鬆實現這一點：

class User < ApplicationRecord
  has_one :profile

  delegate_missing_to :profile
end

目標可以是對象內的任何可調用項，例如實例變量、方法、常量等。只有目標的公共方法被委託。

注意：定義在active_support/core_ext/module/delegation.rb中。

3.5 重新定義方法

有些情況下，您需要使用define_method定義一個方法，但不知道是否已經存在具有該名稱的方法。如果已經存在，則會發出警告（如果已啟用）。這並不是什麼大問題，但也不夠乾淨。

方法redefine_method可以防止此潛在警告，在需要時先刪除現有方法。

如果需要自己定義替換方法（例如使用delegate），也可以使用silence_redefinition_of_method。

注意：定義在active_support/core_ext/module/redefine_method.rb中。

4 `Class`的擴展

4.1 類屬性

4.1.1 `class_attribute`

方法class_attribute聲明一個或多個可繼承的類屬性，可以在層次結構中的任何級別上被覆蓋。

class A
  class_attribute :x
end

class B < A; end

class C < B; end

A.x = :a
B.x # => :a
C.x # => :a

B.x = :b
A.x # => :a
C.x # => :b

C.x = :c
A.x # => :a
B.x # => :b

例如，ActionMailer::Base定義了：

class_attribute :default_params
self.default_params = {
  mime_version: "1.0",
  charset: "UTF-8",
  content_type: "text/plain",
  parts_order: [ "text/plain", "text/enriched", "text/html" ]
}.freeze

它們也可以在實例級別上訪問和覆蓋。

A.x = 1

a1 = A.new
a2 = A.new
a2.x = 2

a1.x # => 1，來自A
a2.x # => 2，在a2中被覆蓋

通過將選項:instance_writer設置為false，可以防止生成寫入器實例方法。

module ActiveRecord
  class Base
    class_attribute :table_name_prefix, instance_writer: false, default: "my"
  end
end

模型可能會發現這個選項對於防止批量賦值設置屬性很有用。

通過將選項:instance_reader設置為false，可以防止生成讀取器實例方法。

class A
  class_attribute :x, instance_reader: false
end

A.new.x = 1
A.new.x # NoMethodError

為了方便起見，class_attribute還定義了一個實例謂詞，它是實例讀取器返回的雙重否定。在上面的例子中，它將被稱為x?。當 :instance_reader 設為 false 時，實例的 predicate 會回傳 NoMethodError，就像 reader 方法一樣。

如果不想要實例的 predicate，可以傳遞 instance_predicate: false，這樣就不會定義它。

注意：定義在 active_support/core_ext/class/attribute.rb 中。

4.1.2 `cattr_reader`、`cattr_writer` 和 `cattr_accessor`

宏 cattr_reader、cattr_writer 和 cattr_accessor 與它們的 attr_* 對應物類似，但是針對類別。它們會將類別變數初始化為 nil，除非它已經存在，並生成相應的類別方法來存取它：

class MysqlAdapter < AbstractAdapter
  # 生成存取 @@emulate_booleans 的類別方法。
  cattr_accessor :emulate_booleans
end

此外，你可以傳遞一個區塊給 cattr_*，以設定屬性的預設值：

class MysqlAdapter < AbstractAdapter
  # 生成存取 @@emulate_booleans 的類別方法，並設定預設值為 true。
  cattr_accessor :emulate_booleans, default: true
end

方便起見，也會生成實例方法，它們只是類別屬性的代理。因此，實例可以更改類別屬性，但不能覆蓋它，就像 class_attribute 一樣（參見上文）。例如，給定以下程式碼：

module ActionView
  class Base
    cattr_accessor :field_error_proc, default: Proc.new { ... }
  end
end

我們可以在視圖中存取 field_error_proc。

可以通過將 :instance_reader 設為 false 來阻止生成讀取實例方法，並通過將 :instance_writer 設為 false 來阻止生成寫入實例方法。可以通過將 :instance_accessor 設為 false 來阻止生成這兩個方法。在所有情況下，值必須正好是 false，而不是任何假值。

module A
  class B
    # 不會生成 first_name 的實例讀取方法。
    cattr_accessor :first_name, instance_reader: false
    # 不會生成 last_name= 的實例寫入方法。
    cattr_accessor :last_name, instance_writer: false
    # 不會生成 surname 的實例讀取方法或 surname= 的寫入方法。
    cattr_accessor :surname, instance_accessor: false
  end
end

模型可能會發現將 :instance_accessor 設為 false 是一種防止批量賦值設置屬性的方法。

注意：定義在 active_support/core_ext/module/attribute_accessors.rb 中。

4.2 子類和後代

4.2.1 `subclasses`

subclasses 方法返回接收者的子類：

class C; end
C.subclasses # => []

class B < C; end
C.subclasses # => [B]

class A < B; end
C.subclasses # => [B]

class D < C; end
C.subclasses # => [B, D]

返回這些類的順序是不確定的。

注意：定義在 active_support/core_ext/class/subclasses.rb 中。

4.2.2 `descendants`

descendants 方法返回所有小於接收者的類：

class C; end
C.descendants # => []

class B < C; end
C.descendants # => [B]

class A < B; end
C.descendants # => [B, A]

class D < C; end
C.descendants # => [B, A, D]

返回這些類的順序是不確定的。

注意：定義在 active_support/core_ext/class/subclasses.rb 中。

將數據插入 HTML 模板需要額外的注意。例如，你不能直接將 @review.title 插入 HTML 頁面中。首先，如果評論標題是 "Flanagan & Matz rules!"，輸出將不符合格式，因為 ampersand 必須被轉義為 "&"。此外，根據應用程序，這可能是一個重大的安全漏洞，因為用戶可以通過設置特製的評論標題來注入惡意 HTML。有關風險的更多信息，請參閱安全指南中有關跨站腳本的部分。

5.1.2 安全字串

Active Support 中有一個 (html) safe 字串的概念。安全字串是一個被標記為可以直接插入 HTML 的字串。無論是否已經進行了轉義，它都是可信任的。

預設情況下，字串被視為 不安全：

"".html_safe? # => false

你可以使用 html_safe 方法從給定的字串獲取一個安全字串：

s = "".html_safe
s.html_safe? # => true

重要的是要理解，html_safe 不會進行任何轉義，它只是一個斷言：

s = "<script>...</script>".html_safe
s.html_safe? # => true
s            # => "<script>...</script>"

確保在特定字串上調用 html_safe 是安全的是你的責任。

如果你使用 concat/<< 或 + 在安全字串上進行附加操作，結果將是一個安全字串。不安全的參數將被轉義：

"".html_safe + "<" # => "&lt;"

安全的參數將直接附加：

"".html_safe + "<".html_safe # => "<"

這些方法不應該在普通的視圖中使用。不安全的值將自動進行轉義：

<%= @review.title %> <%# 如果需要，進行轉義是安全的 %>

如果要直接插入某個字串，請使用 raw 輔助方法，而不是調用 html_safe：

<%= raw @cms.current_template %> <%# 將 @cms.current_template 原樣插入 %>

或者，可以使用 <%==：

<%== @cms.current_template %> <%# 將 @cms.current_template 原樣插入 %>

raw 輔助方法會為你調用 html_safe：

def raw(stringish)
  stringish.to_s.html_safe
end

注意：定義在 active_support/core_ext/string/output_safety.rb 中。

5.1.3 轉換

一般來說，除了上面解釋的連接操作，任何可能改變字串的方法都會返回一個不安全的字串。這些方法包括 downcase、gsub、strip、chomp、underscore 等等。

對於像 gsub! 這樣的原地轉換，接收者本身也會變成不安全的。

註：無論轉換是否實際改變了內容，安全標記都會丟失。

5.1.4 轉換和強制轉型

在安全字串上調用 to_s 會返回一個安全字串，但是使用 to_str 強制轉型會返回一個不安全的字串。

5.1.5 複製

在安全字串上調用 dup 或 clone 會返回一個安全字串。

5.2 `remove`

remove 方法將刪除所有匹配的模式：

"Hello World".remove(/Hello /) # => "World"

還有一個具有破壞性的版本 String#remove!。

註：定義在 active_support/core_ext/string/filters.rb 中。

5.3 `squish`

squish 方法會刪除前後的空白字符，並將連續的空白字符替換為一個空格：

" \n  foo\n\r \t bar \n".squish # => "foo bar"

還有一個具有破壞性的版本 String#squish!。

請注意，它可以處理 ASCII 和 Unicode 的空白字符。

註：定義在 active_support/core_ext/string/filters.rb 中。

5.4 `truncate`

truncate 方法會返回一個在指定 length 之後被截斷的副本：

"Oh dear! Oh dear! I shall be late!".truncate(20)
# => "Oh dear! Oh dear!..."

省略號可以使用 :omission 選項自定義：

"Oh dear! Oh dear! I shall be late!".truncate(20, omission: '&hellip;')
# => "Oh dear! Oh &hellip;"

特別注意，截斷時會考慮省略號的長度。

如果要在自然斷點處截斷字串，可以傳遞 :separator：

```ruby
"Oh dear! Oh dear! I shall be late!".truncate(18)
# => "Oh dear! Oh dea..."
"Oh dear! Oh dear! I shall be late!".truncate(18, separator: ' ')
# => "Oh dear! Oh..."

選項 :separator 可以是正則表達式：

"Oh dear! Oh dear! I shall be late!".truncate(18, separator: /\s/)
# => "Oh dear! Oh..."

在上面的例子中，"dear" 被截斷了，但是 :separator 選項阻止了這種情況。

注意：定義在 active_support/core_ext/string/filters.rb。

5.5 `truncate_bytes`

方法 truncate_bytes 返回一個被截斷到最多 bytesize 字節的接收者的副本：

"👍👍👍👍".truncate_bytes(15)
# => "👍👍👍…"

省略號可以通過 :omission 選項自定義：

"👍👍👍👍".truncate_bytes(15, omission: "🖖")
# => "👍👍🖖"

注意：定義在 active_support/core_ext/string/filters.rb。

5.6 `truncate_words`

方法 truncate_words 返回一個在給定的單詞數之後被截斷的接收者的副本：

"Oh dear! Oh dear! I shall be late!".truncate_words(4)
# => "Oh dear! Oh dear!..."

省略號可以通過 :omission 選項自定義：

"Oh dear! Oh dear! I shall be late!".truncate_words(4, omission: '&hellip;')
# => "Oh dear! Oh dear!&hellip;"

通過 :separator 選項將字符串截斷在自然斷點處：

"Oh dear! Oh dear! I shall be late!".truncate_words(3, separator: '!')
# => "Oh dear! Oh dear! I shall be late..."

選項 :separator 可以是正則表達式：

"Oh dear! Oh dear! I shall be late!".truncate_words(4, separator: /\s/)
# => "Oh dear! Oh dear!..."

注意：定義在 active_support/core_ext/string/filters.rb。

5.7 `inquiry`

inquiry 方法將字符串轉換為 StringInquirer 對象，使相等性檢查更漂亮。

"production".inquiry.production? # => true
"active".inquiry.inactive?       # => false

注意：定義在 active_support/core_ext/string/inquiry.rb。

5.8 `starts_with?` 和 `ends_with?`

Active Support 定義了 String#start_with? 和 String#end_with? 的第三人稱別名：

"foo".starts_with?("f") # => true
"foo".ends_with?("o")   # => true

注意：定義在 active_support/core_ext/string/starts_ends_with.rb。

5.9 `strip_heredoc`

方法 strip_heredoc 去除 heredoc 中的縮進。

例如，在

if options[:usage]
  puts <<-USAGE.strip_heredoc
    This command does such and such.

    Supported options are:
      -h         This message
      ...
  USAGE
end

中，用戶將看到對齊左邊邊緣的使用消息。

從技術上講，它在整個字符串中尋找最少縮進的行，並刪除相應數量的前導空格。

注意：定義在 active_support/core_ext/string/strip.rb。

5.10 `indent`

indent 方法縮進接收者的行：

<<EOS.indent(2)
def some_method
  some_code
end
EOS
# =>
  def some_method
    some_code
  end

第二個參數 indent_string 指定要使用的縮進字符串。默認值為 nil，表示方法將根據第一個縮進的行進行猜測，如果沒有，則使用空格。

"  foo".indent(2)        # => "    foo"
"foo\n\t\tbar".indent(2) # => "\t\tfoo\n\t\t\t\tbar"
"foo".indent(2, "\t")    # => "\t\tfoo"

雖然 indent_string 通常是一個空格或制表符，但它可以是任何字符串。

第三個參數 indent_empty_lines 是一個標誌，表示是否應該縮進空行。默認值為 false。

"foo\n\nbar".indent(2)            # => "  foo\n\n  bar"
"foo\n\nbar".indent(2, nil, true) # => "  foo\n  \n  bar"

indent! 方法在原地執行縮進。

注意：定義在 active_support/core_ext/string/indent.rb。

5.11 存取

5.11.1 `at(position)`

at 方法返回字符串在位置 position 的字符：

"hello".at(0)  # => "h"
"hello".at(4)  # => "o"
"hello".at(-1) # => "o"
"hello".at(10) # => nil

注意：定义在 active_support/core_ext/string/access.rb 中。

5.11.2 `from(position)`

from 方法返回从位置 position 开始的字符串子串：

"hello".from(0)  # => "hello"
"hello".from(2)  # => "llo"
"hello".from(-2) # => "lo"
"hello".from(10) # => nil

注意：定义在 active_support/core_ext/string/access.rb 中。

5.11.3 `to(position)`

to 方法返回字符串到位置 position 的子串：

"hello".to(0)  # => "h"
"hello".to(2)  # => "hel"
"hello".to(-2) # => "hell"
"hello".to(10) # => "hello"

注意：定义在 active_support/core_ext/string/access.rb 中。

5.11.4 `first(limit = 1)`

first 方法返回字符串的前 limit 个字符的子串。

调用 str.first(n) 等同于 str.to(n-1)，如果 n > 0，对于 n == 0，返回空字符串。

注意：定义在 active_support/core_ext/string/access.rb 中。

5.11.5 `last(limit = 1)`

last 方法返回字符串的后 limit 个字符的子串。

调用 str.last(n) 等同于 str.from(-n)，如果 n > 0，对于 n == 0，返回空字符串。

注意：定义在 active_support/core_ext/string/access.rb 中。

5.12 變化形式

5.12.1 `pluralize`

pluralize 方法返回其接收者的複數形式：

"table".pluralize     # => "tables"
"ruby".pluralize      # => "rubies"
"equipment".pluralize # => "equipment"

如前面的例子所示，Active Support 知道一些不規則的複數形式和不可數名詞。內建的規則可以在 config/initializers/inflections.rb 中擴展。這個文件是默認由 rails new 命令生成的，並且有註釋中的指示。

pluralize 方法也可以接受一個可選的 count 參數。如果 count == 1，則返回單數形式。對於任何其他值的 count，返回複數形式：

"dude".pluralize(0) # => "dudes"
"dude".pluralize(1) # => "dude"
"dude".pluralize(2) # => "dudes"

Active Record 使用這個方法來計算對應於模型的默認表名：

# active_record/model_schema.rb
def undecorated_table_name(model_name)
  table_name = model_name.to_s.demodulize.underscore
  pluralize_table_names ? table_name.pluralize : table_name
end

注意：定义在 active_support/core_ext/string/inflections.rb 中。

5.12.2 `singularize`

singularize 方法是 pluralize 的反向操作：

"tables".singularize    # => "table"
"rubies".singularize    # => "ruby"
"equipment".singularize # => "equipment"

關聯使用這個方法來計算對應的默認關聯類名：

# active_record/reflection.rb
def derive_class_name
  class_name = name.to_s.camelize
  class_name = class_name.singularize if collection?
  class_name
end

注意：定义在 active_support/core_ext/string/inflections.rb 中。

5.12.3 `camelize`

camelize 方法返回其接收者的駝峰命名形式：

"product".camelize    # => "Product"
"admin_user".camelize # => "AdminUser"

作為一個經驗法則，可以將這個方法視為將路徑轉換為 Ruby 類或模塊名稱的方法，其中斜線分隔命名空間：

"backoffice/session".camelize # => "Backoffice::Session"

例如，Action Pack 使用這個方法來加載提供特定會話存儲的類：

# action_controller/metal/session_management.rb
def session_store=(store)
  @@session_store = store.is_a?(Symbol) ?
    ActionDispatch::Session.const_get(store.to_s.camelize) :
    store
end

camelize 接受一個可選的參數，可以是 :upper（默認值）或 :lower。使用後者，第一個字母變為小寫： ruby "visual_effect".camelize(:lower) # => "visualEffect"

這在計算符合該慣例的語言（例如JavaScript）中的方法名稱時很方便。

一般而言，您可以將 camelize 視為 underscore 的相反操作，但有些情況下並非如此："SSLError".underscore.camelize 會得到 "SslError"。為了支援這種情況，Active Support 允許您在 config/initializers/inflections.rb 中指定首字母縮寫：

ActiveSupport::Inflector.inflections do |inflect|
  inflect.acronym 'SSL'
end

"SSLError".underscore.camelize # => "SSLError"

camelize 被別名為 camelcase。

注意：定義在 active_support/core_ext/string/inflections.rb 中。

5.12.4 `underscore`

underscore 方法則相反，將駝峰命名法轉換為路徑：

"Product".underscore   # => "product"
"AdminUser".underscore # => "admin_user"

同時將 "::" 轉換為 "/":

"Backoffice::Session".underscore # => "backoffice/session"

並且可以處理以小寫字母開頭的字串：

"visualEffect".underscore # => "visual_effect"

underscore 不接受任何參數。

Rails 使用 underscore 來為控制器類獲取小寫名稱：

# actionpack/lib/abstract_controller/base.rb
def controller_path
  @controller_path ||= name.delete_suffix("Controller").underscore
end

例如，該值是在 params[:controller] 中獲取的。

一般而言，您可以將 underscore 視為 camelize 的相反操作，但有些情況下並非如此。例如，"SSLError".underscore.camelize 會得到 "SslError"。

注意：定義在 active_support/core_ext/string/inflections.rb 中。

5.12.5 `titleize`

titleize 方法將接收者中的單詞首字母大寫：

"alice in wonderland".titleize # => "Alice In Wonderland"
"fermat's enigma".titleize     # => "Fermat's Enigma"

titleize 被別名為 titlecase。

注意：定義在 active_support/core_ext/string/inflections.rb 中。

5.12.6 `dasherize`

dasherize 方法將接收者中的底線替換為破折號：

"name".dasherize         # => "name"
"contact_data".dasherize # => "contact-data"

模型的 XML 序列化器使用此方法將節點名稱轉換為破折號：

# active_model/serializers/xml.rb
def reformat_name(name)
  name = name.camelize if camelize?
  dasherize? ? name.dasherize : name
end

注意：定義在 active_support/core_ext/string/inflections.rb 中。

5.12.7 `demodulize`

給定一個帶有限定常數名稱的字符串，demodulize 返回該常數名稱的最右邊部分：

"Product".demodulize                        # => "Product"
"Backoffice::UsersController".demodulize    # => "UsersController"
"Admin::Hotel::ReservationUtils".demodulize # => "ReservationUtils"
"::Inflections".demodulize                  # => "Inflections"
"".demodulize                               # => ""

例如，Active Record 使用此方法來計算計數緩存列的名稱：

# active_record/reflection.rb
def counter_cache_column
  if options[:counter_cache] == true
    "#{active_record.name.demodulize.underscore.pluralize}_count"
  elsif options[:counter_cache]
    options[:counter_cache]
  end
end

注意：定義在 active_support/core_ext/string/inflections.rb 中。

5.12.8 `deconstantize`

給定一個帶有限定常數引用表達式的字符串，deconstantize 移除最右邊的部分，通常保留常數的容器名稱：

"Product".deconstantize                        # => ""
"Backoffice::UsersController".deconstantize    # => "Backoffice"
"Admin::Hotel::ReservationUtils".deconstantize # => "Admin::Hotel"

注意：定義在 active_support/core_ext/string/inflections.rb 中。

5.12.9 `parameterize`

parameterize 方法將接收者規範化，以便在漂亮的 URL 中使用。

"John Smith".parameterize # => "john-smith"
"Kurt Gödel".parameterize # => "kurt-godel"

要保留字符串的大小寫，將 preserve_case 參數設置為 true。默認情況下，preserve_case 設置為 false。

"John Smith".parameterize(preserve_case: true) # => "John-Smith"
"Kurt Gödel".parameterize(preserve_case: true) # => "Kurt-Godel"

要使用自定義分隔符，覆蓋 separator 參數。

"John Smith".parameterize(separator: "_") # => "john_smith"
"Kurt Gödel".parameterize(separator: "_") # => "kurt_godel"

注意：在active_support/core_ext/string/inflections.rb中定义。

5.12.10 `tableize`

方法tableize是underscore后跟pluralize。

"Person".tableize      # => "people"
"Invoice".tableize     # => "invoices"
"InvoiceLine".tableize # => "invoice_lines"

作为一个经验法则，对于简单的情况，tableize返回与给定模型对应的表名。实际在Active Record中的实现并不是直接的tableize，因为它还会对类名进行去模块化处理，并检查一些可能影响返回字符串的选项。

注意：在active_support/core_ext/string/inflections.rb中定义。

5.12.11 `classify`

方法classify是tableize的反函数。它给出与表名对应的类名：

"people".classify        # => "Person"
"invoices".classify      # => "Invoice"
"invoice_lines".classify # => "InvoiceLine"

该方法可以理解限定的表名：

"highrise_production.companies".classify # => "Company"

请注意，classify返回一个类名字符串。您可以通过在其上调用constantize来获取实际的类对象，下面会解释。

注意：在active_support/core_ext/string/inflections.rb中定义。

5.12.12 `constantize`

方法constantize解析其接收者中的常量引用表达式：

"Integer".constantize # => Integer

module M
  X = 1
end
"M::X".constantize # => 1

如果字符串不是已知常量的名称，或者其内容甚至不是有效的常量名称，constantize会引发NameError。

constantize通过始终从顶级Object开始解析常量名称，即使没有前导的"::"，来进行常量名称解析。

X = :in_Object
module M
  X = :in_M

  X                 # => :in_M
  "::X".constantize # => :in_Object
  "X".constantize   # => :in_Object (!)
end

因此，它通常不等同于Ruby在同一位置上执行的真实常量求值。

Mailer测试用例使用constantize从测试类的名称获取正在测试的mailer：

# action_mailer/test_case.rb
def determine_default_mailer(name)
  name.delete_suffix("Test").constantize
rescue NameError => e
  raise NonInferrableMailerError.new(name)
end

注意：在active_support/core_ext/string/inflections.rb中定义。

5.12.13 `humanize`

方法humanize调整属性名称以供最终用户显示。

具体来说，它执行以下转换：

对参数应用人类化规则。
删除前导下划线（如果有）。
如果存在，删除"_id"后缀。
如果有下划线，则将其替换为空格。
除了首字母缩写词外，将所有单词小写。
将第一个单词大写。

可以通过将:capitalize选项设置为false（默认为true）来关闭对第一个单词的大写。

"name".humanize                         # => "Name"
"author_id".humanize                    # => "Author"
"author_id".humanize(capitalize: false) # => "author"
"comments_count".humanize               # => "Comments count"
"_id".humanize                          # => "Id"

如果"SSL"被定义为首字母缩写：

'ssl_error'.humanize # => "SSL error"

辅助方法full_messages使用humanize作为回退来包含属性名称：

def full_messages
  map { |attribute, message| full_message(attribute, message) }
end

def full_message
  # ...
  attr_name = attribute.to_s.tr('.', '_').humanize
  attr_name = @base.class.human_attribute_name(attribute, default: attr_name)
  # ...
end

注意：在active_support/core_ext/string/inflections.rb中定义。

5.12.14 `foreign_key`

方法foreign_key从类名中获取外键列名。为此，它会去模块化、添加下划线，并添加"_id"：

"User".foreign_key           # => "user_id"
"InvoiceLine".foreign_key    # => "invoice_line_id"
"Admin::Session".foreign_key # => "session_id"

如果您不想在"_id"中使用底線，請傳遞一個錯誤的參數：

"User".foreign_key(false) # => "userid"

關聯使用此方法來推斷外鍵，例如has_one和has_many這樣做：

# active_record/associations.rb
foreign_key = options[:foreign_key] || reflection.active_record.name.foreign_key

注意：在active_support/core_ext/string/inflections.rb中定義。

5.12.15 `upcase_first`

方法upcase_first將接收者的第一個字母大寫：

"employee salary".upcase_first # => "Employee salary"
"".upcase_first                # => ""

注意：在active_support/core_ext/string/inflections.rb中定義。

5.12.16 `downcase_first`

方法downcase_first將接收者的第一個字母轉換為小寫：

"If I had read Alice in Wonderland".downcase_first # => "if I had read Alice in Wonderland"
"".downcase_first                                  # => ""

注意：在active_support/core_ext/string/inflections.rb中定義。

5.13 轉換

5.13.1 `to_date`、`to_time`、`to_datetime`

方法to_date、to_time和to_datetime基本上是對Date._parse的方便封裝：

"2010-07-27".to_date              # => Tue, 27 Jul 2010
"2010-07-27 23:37:00".to_time     # => 2010-07-27 23:37:00 +0200
"2010-07-27 23:37:00".to_datetime # => Tue, 27 Jul 2010 23:37:00 +0000

to_time接收一個可選的參數:utc或:local，用於指示您希望時間在哪個時區：

"2010-07-27 23:42:00".to_time(:utc)   # => 2010-07-27 23:42:00 UTC
"2010-07-27 23:42:00".to_time(:local) # => 2010-07-27 23:42:00 +0200

默認值為:local。

請參閱Date._parse的文檔以獲取更多詳細信息。

INFO：它們三個都對於空接收者返回nil。

注意：在active_support/core_ext/string/conversions.rb中定義。

6 `Symbol`的擴展

6.1 `starts_with?`和`ends_with?`

Active Support定義了Symbol#start_with?和Symbol#end_with?的第三人稱別名：

:foo.starts_with?("f") # => true
:foo.ends_with?("o")   # => true

注意：在active_support/core_ext/symbol/starts_ends_with.rb中定義。

7 `Numeric`的擴展

7.1 Bytes

所有數字都會響應這些方法：

它們返回相應的字節數，使用1024的換算因子：

2.kilobytes   # => 2048
3.megabytes   # => 3145728
3.5.gigabytes # => 3758096384.0
-4.exabytes   # => -4611686018427387904

單數形式被別名，因此您可以這樣說：

1.megabyte # => 1048576

注意：在active_support/core_ext/numeric/bytes.rb中定義。

7.2 Time

以下方法：

使時間聲明和計算成為可能，例如45.minutes + 2.hours + 4.weeks。它們的返回值也可以添加到或從時間對象中減去。

這些方法可以與from_now、ago等結合使用，進行精確的日期計算。例如：

# 等同於 Time.current.advance(days: 1)
1.day.from_now

# 等同於 Time.current.advance(weeks: 2)
2.weeks.from_now

# 等同於 Time.current.advance(days: 4, weeks: 5)
(4.days + 5.weeks).from_now

警告：對於其他持續時間，請參閱對Integer的時間擴展。

注意：在active_support/core_ext/numeric/time.rb中定義。

7.3 格式化

使數字以各種方式進行格式化。

將數字作為電話號碼的字符串表示形式：

5551234.to_fs(:phone)
# => 555-1234
1235551234.to_fs(:phone)
# => 123-555-1234
1235551234.to_fs(:phone, area_code: true)
# => (123) 555-1234
1235551234.to_fs(:phone, delimiter: " ")
# => 123 555 1234
1235551234.to_fs(:phone, area_code: true, extension: 555)
# => (123) 555-1234 x 555
1235551234.to_fs(:phone, country_code: 1)
# => +1-123-555-1234

將數字作為貨幣的字符串表示形式：

1234567890.50.to_fs(:currency)                 # => $1,234,567,890.50
1234567890.506.to_fs(:currency)                # => $1,234,567,890.51
1234567890.506.to_fs(:currency, precision: 3)  # => $1,234,567,890.506

將數字以百分比的形式轉換為字符串表示：

100.to_fs(:percentage)
# => 100.000%
100.to_fs(:percentage, precision: 0)
# => 100%
1000.to_fs(:percentage, delimiter: '.', separator: ',')
# => 1.000,000%
302.24398923423.to_fs(:percentage, precision: 5)
# => 302.24399%

將數字以分隔形式轉換為字符串表示：

12345678.to_fs(:delimited)                     # => 12,345,678
12345678.05.to_fs(:delimited)                  # => 12,345,678.05
12345678.to_fs(:delimited, delimiter: ".")     # => 12.345.678
12345678.to_fs(:delimited, delimiter: ",")     # => 12,345,678
12345678.05.to_fs(:delimited, separator: " ")  # => 12,345,678 05

將數字四捨五入到指定的精度：

111.2345.to_fs(:rounded)                     # => 111.235
111.2345.to_fs(:rounded, precision: 2)       # => 111.23
13.to_fs(:rounded, precision: 5)             # => 13.00000
389.32314.to_fs(:rounded, precision: 0)      # => 389
111.2345.to_fs(:rounded, significant: true)  # => 111

將數字以人類可讀的字節數形式轉換為字符串表示：

123.to_fs(:human_size)                  # => 123 Bytes
1234.to_fs(:human_size)                 # => 1.21 KB
12345.to_fs(:human_size)                # => 12.1 KB
1234567.to_fs(:human_size)              # => 1.18 MB
1234567890.to_fs(:human_size)           # => 1.15 GB
1234567890123.to_fs(:human_size)        # => 1.12 TB
1234567890123456.to_fs(:human_size)     # => 1.1 PB
1234567890123456789.to_fs(:human_size)  # => 1.07 EB

將數字以人類可讀的詞語形式轉換為字符串表示：

123.to_fs(:human)               # => "123"
1234.to_fs(:human)              # => "1.23 Thousand"
12345.to_fs(:human)             # => "12.3 Thousand"
1234567.to_fs(:human)           # => "1.23 Million"
1234567890.to_fs(:human)        # => "1.23 Billion"
1234567890123.to_fs(:human)     # => "1.23 Trillion"
1234567890123456.to_fs(:human)  # => "1.23 Quadrillion"

注意：定義在 active_support/core_ext/numeric/conversions.rb 中。

8 `Integer` 的擴展

8.1 `multiple_of?`

multiple_of? 方法用於測試一個整數是否為另一個整數的倍數：

2.multiple_of?(1) # => true
1.multiple_of?(2) # => false

注意：定義在 active_support/core_ext/integer/multiple.rb 中。

8.2 `ordinal`

ordinal 方法返回與接收方整數對應的序數後綴字符串：

1.ordinal    # => "st"
2.ordinal    # => "nd"
53.ordinal   # => "rd"
2009.ordinal # => "th"
-21.ordinal  # => "st"
-134.ordinal # => "th"

注意：定義在 active_support/core_ext/integer/inflections.rb 中。

8.3 `ordinalize`

ordinalize 方法返回與接收方整數對應的序數字符串。請注意，ordinal 方法僅返回後綴字符串。

1.ordinalize    # => "1st"
2.ordinalize    # => "2nd"
53.ordinalize   # => "53rd"
2009.ordinalize # => "2009th"
-21.ordinalize  # => "-21st"
-134.ordinalize # => "-134th"

注意：定義在 active_support/core_ext/integer/inflections.rb 中。

8.4 Time

以下方法：

允許時間的聲明和計算，例如 4.months + 5.years。它們的返回值也可以添加到或從時間對象中減去。

這些方法可以與 from_now、ago 等結合使用，進行精確的日期計算。例如：

# 等同於 Time.current.advance(months: 1)
1.month.from_now

# 等同於 Time.current.advance(years: 2)
2.years.from_now

# 等同於 Time.current.advance(months: 4, years: 5)
(4.months + 5.years).from_now

警告：對於其他持續時間，請參考對 Numeric 的時間擴展。

注意：定義在 active_support/core_ext/integer/time.rb 中。

9 `BigDecimal` 的擴展

9.1 `to_s`

to_s 方法提供了默認的 "F" 類型。這意味著對 to_s 的簡單調用將得到浮點表示，而不是工程表示法：

BigDecimal(5.00, 6).to_s       # => "5.0"

仍然支持工程表示法：

BigDecimal(5.00, 6).to_s("e")  # => "0.5E1"

10 `Enumerable` 的擴展

10.1 `sum`

sum 方法將可枚舉對象的元素相加： ruby [1, 2, 3].sum # => 6 (1..100).sum # => 5050

加法只假設元素能夠回應 +：

[[1, 2], [2, 3], [3, 4]].sum    # => [1, 2, 2, 3, 3, 4]
%w(foo bar baz).sum             # => "foobarbaz"
{ a: 1, b: 2, c: 3 }.sum          # => [:a, 1, :b, 2, :c, 3]

預設情況下，空集合的總和為零，但這是可以自定義的：

[].sum    # => 0
[].sum(1) # => 1

如果給定了一個塊，sum 將成為一個迭代器，它會遍歷集合的元素並對返回的值進行求和：

(1..5).sum { |n| n * 2 } # => 30
[2, 4, 6, 8, 10].sum    # => 30

空接收者的總和也可以以這種形式進行自定義：

[].sum(1) { |n| n**3 } # => 1