傳回 true 如果資料表中存在符合 id 或所提供的條件的記錄，否則傳回 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 將會被引發。如果主鍵是一個整數，那麼根據 id 尋找會使用 `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.

特殊情況

Person.find(37)          # raises ActiveRecord::RecordNotFound exception if the record with the given ID does not exist.
Person.find([37])        # raises ActiveRecord::RecordNotFound exception if the record with the given ID in the input array does not exist.
Person.find(nil)         # raises ActiveRecord::RecordNotFound exception if the argument is nil.
Person.find([])          # returns an empty array if the argument is an empty array.
Person.find              # raises ActiveRecord::RecordNotFound exception if the argument is not provided.

尋找符合指定條件的第一筆記錄。沒有指明排序，所以如果排序很重要，您應自行指定。

如果找不到記錄，傳回 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! 不接受任何引數。

找出第四十二筆紀錄。又稱為存取「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。

找出第四筆紀錄。若未定義順序，則會按主鍵順序排列。

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。