如果表中存在与给定的 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”将是值数组。如果无法为请求的 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.

查找与指定条件匹配的第一条记录。没有隐含的排序，因此如果顺序很重要，您应该自己指定。

如果没有找到记录，则返回 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。

查找第四条记录。如果没有定义顺序，它将按主键排序。

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。