如果表中存在与给定的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。如果主键是整数，则按 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! 不接受任何参数。

查找第 42 条记录。也称为访问“the 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。