如果存在与给定的 `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。如果主键是整数，则通过使用 `to_i` 来强制转换 id 的参数。

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。