如果資料表中存在與給定的 id 或條件相符的記錄，則傳回 true，否則傳回 false。參數可以有六種形式

• Integer - 找出具有此主鍵的記錄。

• String - 找出主鍵對應到此字串的記錄（例如 '5'）。

• Array - 找出符合這些 where 樣式條件的記錄（例如 ['name LIKE ?', "%#{query}%"]）。

• Hash - 找出符合這些 where 樣式條件的記錄（例如 {name: 'David'}）。

• false - 永遠傳回 false。

• 沒有參數 - 如果關係為空，則傳回 false，否則傳回 true。

有關將條件指定為雜湊或陣列的詳細資訊，請參閱 ActiveRecord::Base 簡介中的條件部分。

注意：您無法傳入字串條件（例如 name = 'Jamie'），因為它會被清除，然後針對主鍵欄位進行查詢，例如 id = 'name = \'Jamie\''。

Person.exists?(5)
Person.exists?('5')
Person.exists?(['name LIKE ?', "%#{query}%"])
Person.exists?(id: [1, 4, 8])
Person.exists?(name: 'David')
Person.exists?(false)
Person.exists?
Person.where(name: 'Spartacus', rating: 4).exists?

找出第五筆記錄。如果沒有定義順序，它將按主鍵排序。

Person.fifth # returns the fifth object fetched by SELECT * FROM people
Person.offset(3).fifth # returns the fifth object from OFFSET 3 (which is OFFSET 7)
Person.where(["user_name = :u", { u: user_name }]).fifth

與 fifth 相同，但如果找不到記錄，會引發 ActiveRecord::RecordNotFound。

依 ID 尋找 - 這可以是特定 ID (ID)、ID 清單 (ID、ID、ID) 或 ID 陣列 ([ID、ID、ID])。`ID` 指的是「識別碼」。對於具有單一欄位主鍵的模型，`ID` 會是單一值，而對於具有複合主鍵的模型，它會是值陣列。如果無法針對請求的 ID 找到一個或多個記錄，則會引發 ActiveRecord::RecordNotFound。如果主鍵是整數，`find` 會使用 `to_i` 轉換其參數。

Person.find(1)          # returns the object for ID = 1
Person.find("1")        # returns the object for ID = 1
Person.find("31-sarah") # returns the object for ID = 31
Person.find(1, 2, 6)    # returns an array for objects with IDs in (1, 2, 6)
Person.find([7, 17])    # returns an array for objects with IDs in (7, 17), or with composite primary key [7, 17]
Person.find([1])        # returns an array for the object with ID = 1
Person.where("administrator = 1").order("created_on DESC").find(1)

尋找複合主鍵模型的記錄

TravelRoute.primary_key = [:origin, :destination]

TravelRoute.find(["Ottawa", "London"])
=> #<TravelRoute origin: "Ottawa", destination: "London">

TravelRoute.find([["Paris", "Montreal"]])
=> [#<TravelRoute origin: "Paris", destination: "Montreal">]

TravelRoute.find(["New York", "Las Vegas"], ["New York", "Portland"])
=> [
     #<TravelRoute origin: "New York", destination: "Las Vegas">,
     #<TravelRoute origin: "New York", destination: "Portland">
   ]

TravelRoute.find([["Berlin", "London"], ["Barcelona", "Lisbon"]])
=> [
     #<TravelRoute origin: "Berlin", destination: "London">,
     #<TravelRoute origin: "Barcelona", destination: "Lisbon">
   ]

注意：傳回的記錄與您提供的 ID 順序相同。如果您希望結果由資料庫排序，可以使用 ActiveRecord::QueryMethods#where 方法，並提供明確的 ActiveRecord::QueryMethods#order 選項。但 ActiveRecord::QueryMethods#where 方法不會引發 ActiveRecord::RecordNotFound。

使用鎖定尋找

使用鎖定尋找的範例：想像兩個並發交易：每個交易都會讀取 person.visits == 2，將其加 1，並儲存，導致 person.visits = 3 儲存兩次。透過鎖定列，第二個交易必須等到第一個交易完成；我們會得到預期的 person.visits == 4。

Person.transaction do
  person = Person.lock(true).find(1)
  person.visits += 1
  person.save!
end

find 的變異

Person.where(name: 'Spartacus', rating: 4)
# returns a chainable list (which can be empty).

Person.find_by(name: 'Spartacus', rating: 4)
# returns the first item or nil.

Person.find_or_initialize_by(name: 'Spartacus', rating: 4)
# returns the first item or returns a new instance (requires you call .save to persist against the database).

Person.find_or_create_by(name: 'Spartacus', rating: 4)
# returns the first item or creates it and returns it.

find 的替代方案

Person.where(name: 'Spartacus', rating: 4).exists?(conditions = :none)
# returns a boolean indicating if any record with the given conditions exist.

Person.where(name: 'Spartacus', rating: 4).select("field1, field2, field3")
# returns a chainable list of instances with only the mentioned fields.

Person.where(name: 'Spartacus', rating: 4).ids
# returns an Array of ids.

Person.where(name: 'Spartacus', rating: 4).pluck(:field1, :field2)
# returns an Array of the required fields.

找出符合指定條件的第一筆記錄。此方法沒有隱含的排序，因此如果排序很重要，您應該自行指定。

如果找不到任何記錄，則傳回 nil。

Post.find_by name: 'Spartacus', rating: 4
Post.find_by "published_at < ?", 2.weeks.ago

與 find_by 相同，但如果找不到任何記錄，則會引發 ActiveRecord::RecordNotFound 錯誤。

找出符合條件的唯一記錄。如果找不到任何記錄，則引發 ActiveRecord::RecordNotFound。如果找到多於一筆記錄，則引發 ActiveRecord::SoleRecordExceeded。

Product.find_sole_by(["price = %?", price])

找出第一筆記錄（如果提供參數，則找出前 N 筆記錄）。如果沒有定義排序，則會依據主鍵排序。

Person.first # returns the first object fetched by SELECT * FROM people ORDER BY people.id LIMIT 1
Person.where(["user_name = ?", user_name]).first
Person.where(["user_name = :u", { u: user_name }]).first
Person.order("created_on DESC").offset(5).first
Person.first(3) # returns the first three objects fetched by SELECT * FROM people ORDER BY people.id LIMIT 3

與 first 相同，但如果找不到記錄，會引發 ActiveRecord::RecordNotFound。請注意，first! 不接受任何參數。

尋找第 42 筆記錄。又稱為存取「reddit」。如果沒有定義順序，它將按主鍵排序。

Person.forty_two # returns the forty-second object fetched by SELECT * FROM people
Person.offset(3).forty_two # returns the forty-second object from OFFSET 3 (which is OFFSET 44)
Person.where(["user_name = :u", { u: user_name }]).forty_two

與 forty_two 相同，但如果找不到記錄，會引發 ActiveRecord::RecordNotFound。

尋找第 4 筆記錄。如果沒有定義順序，它將按主鍵排序。

Person.fourth # returns the fourth object fetched by SELECT * FROM people
Person.offset(3).fourth # returns the fourth object from OFFSET 3 (which is OFFSET 6)
Person.where(["user_name = :u", { u: user_name }]).fourth

與 fourth 相同，但如果找不到記錄，會引發 ActiveRecord::RecordNotFound。

如果關係包含給定的記錄，則傳回 true，否則傳回 false。

如果關聯載入，不會執行任何查詢；會將給定的記錄與記憶體中的記錄進行比較。如果關聯卸載，會執行有效的存在查詢，如 exists?。

尋找最後一筆記錄（如果提供參數，則尋找最後 N 筆記錄）。如果未定義順序，它將按主鍵排序。

Person.last # returns the last object fetched by SELECT * FROM people
Person.where(["user_name = ?", user_name]).last
Person.order("created_on DESC").offset(5).last
Person.last(3) # returns the last three objects fetched by SELECT * FROM people.

請注意，在最後一個案例中，結果會按遞增順序排序

[#<Person id:2>, #<Person id:3>, #<Person id:4>]

而不是

[#<Person id:4>, #<Person id:3>, #<Person id:2>]

與 last 相同，但如果找不到記錄，會引發 ActiveRecord::RecordNotFound。請注意，last! 不接受任何參數。

尋找第二筆記錄。如果未定義順序，它將按主鍵排序。

Person.second # returns the second object fetched by SELECT * FROM people
Person.offset(3).second # returns the second object from OFFSET 3 (which is OFFSET 4)
Person.where(["user_name = :u", { u: user_name }]).second

與 second 相同，但如果找不到記錄，會引發 ActiveRecord::RecordNotFound。

尋找倒數第二筆記錄。如果未定義順序，它將按主鍵排序。

Person.second_to_last # returns the second-to-last object fetched by SELECT * FROM people
Person.offset(3).second_to_last # returns the second-to-last object from OFFSET 3
Person.where(["user_name = :u", { u: user_name }]).second_to_last

與 second_to_last 相同，但如果找不到記錄，則會引發 ActiveRecord::RecordNotFound。

找出符合條件的唯一記錄。如果找不到任何記錄，則引發 ActiveRecord::RecordNotFound。如果找到多於一筆記錄，則引發 ActiveRecord::SoleRecordExceeded。

Product.where(["price = %?", price]).sole

提供一個記錄（如果提供參數，則為 N 個記錄），而沒有任何隱含的順序。順序將取決於資料庫實作。如果提供順序，則會尊重它。

Person.take # returns an object fetched by SELECT * FROM people LIMIT 1
Person.take(5) # returns 5 objects fetched by SELECT * FROM people LIMIT 5
Person.where(["name LIKE '%?'", name]).take

與 take 相同，但如果找不到記錄，則會引發 ActiveRecord::RecordNotFound。請注意，take! 不接受任何參數。

尋找第三筆記錄。如果沒有定義順序，則會按主鍵排序。

Person.third # returns the third object fetched by SELECT * FROM people
Person.offset(3).third # returns the third object from OFFSET 3 (which is OFFSET 5)
Person.where(["user_name = :u", { u: user_name }]).third

與 third 相同，但如果找不到記錄，則會引發 ActiveRecord::RecordNotFound。

尋找第三筆最後的記錄。如果沒有定義順序，則會按主鍵排序。

Person.third_to_last # returns the third-to-last object fetched by SELECT * FROM people
Person.offset(3).third_to_last # returns the third-to-last object from OFFSET 3
Person.where(["user_name = :u", { u: user_name }]).third_to_last

與 third_to_last 相同，但若找不到記錄，會引發 ActiveRecord::RecordNotFound。