blocks|key|1031406|text|基本上，destroy在模型上运行任何回调，而delete不运行。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1031407|来自Rails+API|1031408|ActiveRecord::Persistence.delete
删除数据库中的记录并冻结此实例，以反映不应进行任何更改(因为它们不能持久保存)。返回冻结的实例。
只需在记录的主键上使用SQL语句删除该行，就不会执行回调。
若要强制执行对象的before_destroy和after_destroy回调或任何:依赖关联选项，请使用#析构。|unordered-list-item|1031409|ActiveRecord::Persistence.destroy
删除数据库中的记录并冻结此实例，以反映不应进行任何更改(因为它们不能持久保存)。
有一系列与破坏相关的回调。如果before_destroy回调返回false，则此操作将被取消，而destroy返回false。有关详细信息，请参阅ActiveRecord：：回调。|1031410|entityMap|0|LINK|mutability|MUTABLE|url|http://api.rubyonrails.org/|1|http://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-delete|2|http://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-destroy^0|4|7|N|6|0|2|9|0|0|0|W|0|W|1|0|0|X|0|X|2|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@$9|14|A|15|1|16]]|E|$]]|$1|H|3|I|5|J|7|17|8|@$9|18|A|19|B|C]]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|K|3|L|5|J|7|1D|8|@$9|1E|A|1F|B|C]]|D|@$9|1G|A|1H|1|1I]]|E|$]]|$1|M|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]|W|$5|P|Q|R|E|$S|X]]]]

Basically <code>destroy</code> runs any callbacks on the model while <code>delete</code> doesn't.

From the <a href="http://api.rubyonrails.org" rel="noreferrer">Rails API</a>:

<ul>
<li><a href="http://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-delete" rel="noreferrer"><code>ActiveRecord::Persistence.delete</code></a>

<blockquote>
 Deletes the record in the database and freezes this instance to reflect that no changes should be made (since they can't be persisted). Returns the frozen instance.
 
 The row is simply removed with an SQL DELETE statement on the record's primary key, and no callbacks are executed.
 
 To enforce the object's before_destroy and after_destroy callbacks or any :dependent association options, use #destroy.
</blockquote></li>
<li><a href="http://api.rubyonrails.org/classes/ActiveRecord/Persistence.html#method-i-destroy" rel="noreferrer"><code>ActiveRecord::Persistence.destroy</code></a>

<blockquote>
 Deletes the record in the database and freezes this instance to reflect that no changes should be made (since they can't be persisted).
 
 There's a series of callbacks associated with destroy. If the before_destroy callback return false the action is cancelled and destroy returns false. See ActiveRecord::Callbacks for further details.
</blockquote></li>
</ul>

blocks|key|2030422|text|delete只会从db中删除当前对象记录，而不会从db删除与其关联的子记录。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2030423|destroy将从db中删除当前对象记录，并从db中删除与其关联的子记录。|2030424|他们的使用真的很重要：|BOLD|2030425|如果多个父对象共享公共子对象，则对特定父对象调用destroy将删除其他多个父对象之间共享的子对象。|2030426|entityMap^0|0|6|0|0|7|0|0|B|0|O|7|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|U|8|@$9|V|A|W|B|J]]|D|@]|E|$]]|$1|K|3|L|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|N|$]]

<code>delete</code> will only delete current object record from db but not its associated children records from db.

<code>destroy</code> will delete current object record from db and also its associated children record from db.

Their use really matters:

If your multiple parent objects share common children objects, then calling <code>destroy</code> on specific parent object will delete children objects which are shared among other multiple parents.

blocks|key|2030337|text|当您对一个destroy对象或destroy_all对象调用ActiveRecord或destroy_all时，会启动ActiveRecord的“销毁”过程，它将分析要删除的类，确定它对依赖项应该做什么，通过验证运行等等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2030338|当对对象调用delete或delete_all时，ActiveRecord只是尝试对db运行DELETE+FROM+tablename+WHERE+conditions查询，而不执行其他ActiveRecord-level任务。|2030339|entityMap^0|5|7|F|B|U|C|17|B|1N|C|0|6|6|D|A|P|C|1A|12|2L|C|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|I|$]]

When you invoke <code>destroy</code> or <code>destroy_all</code> on an <code>ActiveRecord</code> object, the <code>ActiveRecord</code> 'destruction' process is initiated, it analyzes the class you're deleting, it determines what it should do for dependencies, runs through validations, etc.

When you invoke <code>delete</code> or <code>delete_all</code> on an object, <code>ActiveRecord</code> merely tries to run the <code>DELETE FROM tablename WHERE conditions</code> query against the db, performing no other <code>ActiveRecord</code>-level tasks.

blocks|key|1031320|text|是的，如果您希望在不调用模型回调的情况下快速删除记录，那么这两种方法(使用delete_all+)有一个很大的区别|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1031321|如果您关心您的模型回调，那么使用destroy_all|1031322|从官方文件上|1031323|全班|offset|length|1031324|Destroy_all(条件=零)公众
通过实例化每个记录并调用其破坏方法来破坏记录匹配条件。每个对象的回调都会被执行(包括:依赖关联选项和前_destroy/+Each+_after观察者方法)。返回被销毁的对象的集合；每个对象都将被冻结，以反映不应该进行任何更改(因为它们不能被持久保存)。
注意:当您一次删除多个记录时，实例化、回调执行和删除每条记录可能很费时。它为每个记录生成至少一个SQL查询(或可能更多，以强制执行回调)。如果您想要快速删除许多行，而不需要考虑它们的关联或回调，请使用delete_all。|blockquote|1031325|entityMap|0|LINK|mutability|MUTABLE|url|http://apidock.com/rails/ActiveRecord/Base/destroy_all/class^0|0|0|0|0|2|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|X|8|@]|9|@$H|Y|I|Z|1|10]]|A|$]]|$1|J|3|K|5|L|7|11|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Yes there is a major difference between the two methods
Use delete_all if you want records to be deleted quickly without model callbacks being called

If you care about your models callbacks then use destroy_all

From the official docs

<a href="http://apidock.com/rails/ActiveRecord/Base/destroy_all/class" rel="noreferrer">http://apidock.com/rails/ActiveRecord/Base/destroy_all/class</a>

<blockquote>
 destroy_all(conditions = nil) public
 
 Destroys the records matching conditions by instantiating each record
 and calling its destroy method. Each object’s callbacks are executed
 (including :dependent association options and
 before_destroy/after_destroy Observer methods). Returns the collection
 of objects that were destroyed; each will be frozen, to reflect that
 no changes should be made (since they can’t be persisted).
 
 Note: Instantiation, callback execution, and deletion of each record
 can be time consuming when you’re removing many records at once. It
 generates at least one SQL DELETE query per record (or possibly more,
 to enforce your callbacks). If you want to delete many rows quickly,
 without concern for their associations or callbacks, use delete_all
 instead.
</blockquote>

blocks|key|2030465|text|已经有很多答案了；想多说一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2030466|文档|offset|length|2030467|对于has_many，removed和destroy_all总是调用被删除记录的破坏方法，以便运行回调。但是，delete和delete_all将根据“依赖”选项指定的策略执行删除，或者如果指定了“否:依赖”选项，则它将遵循默认策略。默认策略是什么都不做(将外键与父ids设置在一起)，除了has_many+:+The，默认策略是delete_all+(删除连接记录，而不运行回调)。|blockquote|2030468|delete版本对于ActiveRecord::Association.has_many和ActiveRecord::Base的工作方式不同。对于后者，delete将执行SQL+DELETE并绕过所有验证/回调。前者将根据传递给关联的:dependent选项执行。但是，在测试期间，我发现了以下副作用，即只为delete而不是delete_all运行回调|style|CODE|2030469|dependent:+:destroy示例：|2030470|class+Parent+<+ApplicationRecord
+++has_many+:children,
+++++before_remove:+->+(_)+{+puts+"before_remove+callback"+},
+++++dependent:+:destroy
end

class+Child+<+ApplicationRecord
+++belongs_to+:parent

+++before_destroy+->+{+puts+"before_destroy+callback"+}
end

>+child.delete++++++++++++++++++++++++++++#+Ran+without+callbacks
Child+Destroy+(99.6ms)++DELETE+FROM+"children"+WHERE+"children"."id"+=+$1++[["id",+21]]

>+parent.children.delete(other_child)+++++#+Ran+with+callbacks
before_remove+callback
before_destroy+callback
Child+Destroy+(0.4ms)++DELETE+FROM+"children"+WHERE+"children"."id"+=+$1++[["id",+22]]

>+parent.children.delete_all++++++++++++++#+Ran+without+callbacks
Child+Destroy+(1.0ms)++DELETE+FROM+"children"+WHERE+"children"."parent_id"+=+$1++[["parent_id",+1]]|code-block|syntax|javascript|2030471|entityMap|0|LINK|mutability|MUTABLE|url|https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Delete%2Bor%2Bdestroy-3F^0|0|0|2|0|0|0|0|6|A|Y|19|I|2D|A|39|A|4A|6|4J|A|0|0|J|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@$D|13|E|14|1|15]]|A|$]]|$1|F|3|G|5|H|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|17|8|@$D|18|E|19|K|L]|$D|1A|E|1B|K|L]|$D|1C|E|1D|K|L]|$D|1E|E|1F|K|L]|$D|1G|E|1H|K|L]|$D|1I|E|1J|K|L]|$D|1K|E|1L|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1M|8|@$D|1N|E|1O|K|L]]|9|@]|A|$]]|$1|O|3|P|5|Q|7|1P|8|@]|9|@]|A|$R|S]]|$1|T|3|-4|5|6|7|1Q|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

A lot of answers already; wanted to jump on with a bit more.

<a href="https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Delete+or+destroy-3F" rel="nofollow noreferrer">docs</a>:

<blockquote>
 For has_many, destroy and destroy_all will always call the destroy method of the record(s) being removed so that callbacks are run. However delete and delete_all will either do the deletion according to the strategy specified by the :dependent option, or if no :dependent option is given, then it will follow the default strategy. The default strategy is to do nothing (leave the foreign keys with the parent ids set), except for has_many :through, where the default strategy is delete_all (delete the join records, without running their callbacks).
</blockquote>

The <code>delete</code> verbage works differently for <code>ActiveRecord::Association.has_many</code> and <code>ActiveRecord::Base</code>. For the latter, delete will execute <code>SQL DELETE</code> and bypass all validations/callbacks. The former will be executed based on the <code>:dependent</code> option passed into the association. However, during testing, I found the following side effect where callbacks were only ran for <code>delete</code> and not <code>delete_all</code>

<code>dependent: :destroy</code> Example: 

<pre><code>class Parent &lt; ApplicationRecord
 has_many :children,
 before_remove: -&gt; (_) { puts "before_remove callback" },
 dependent: :destroy
end

class Child &lt; ApplicationRecord
 belongs_to :parent

 before_destroy -&gt; { puts "before_destroy callback" }
end

&gt; child.delete # Ran without callbacks
Child Destroy (99.6ms) DELETE FROM "children" WHERE "children"."id" = $1 [["id", 21]]

&gt; parent.children.delete(other_child) # Ran with callbacks
before_remove callback
before_destroy callback
Child Destroy (0.4ms) DELETE FROM "children" WHERE "children"."id" = $1 [["id", 22]]

&gt; parent.children.delete_all # Ran without callbacks
Child Destroy (1.0ms) DELETE FROM "children" WHERE "children"."parent_id" = $1 [["parent_id", 1]]
</code></pre>

blocks|key|2030584|text|示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2030585|Class+User
++has_many+:contents,+dependent:+:destroy
end

user+=+User.last
user.delete+->+only+user
user.destroy+->+delete+user+,+and+contents+of+user|code-block|syntax|javascript|2030586|delete将从db中删除当前记录(没有回调)|offset|length|style|CODE|2030587|destroy将删除当前记录和相关记录(有回调)|2030588|delete_all和destroy_all也是如此|2030589|entityMap^0|0|0|0|6|0|0|7|0|0|A|B|B|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@$I|Y|J|Z|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@$I|11|J|12|K|L]|$I|13|J|14|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|R|$]]

Example:
<pre><code>Class User
 has_many :contents, dependent: :destroy
end

user = User.last
user.delete -&gt; only user
user.destroy -&gt; delete user , and contents of user
</code></pre>
<code>delete</code> will delete current record from db (No callback)
<code>destroy</code> will delete current record and associated record (Has callback)
The same with <code>delete_all</code> and <code>destroy_all</code>

blocks|key|2030295|text|基本上“删除”将查询直接发送到数据库以删除记录。在这种情况下，Rails不知道它正在删除的记录中有哪些属性，也不知道是否有回调(如before_destroy)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2030296|“破坏”方法接受传递的id，使用"find“方法从数据库中获取模型，然后对其进行调用。这意味着回调将被触发。|2030297|如果不希望触发回调或希望获得更好的性能，则需要使用"delete“。否则(大多数情况下)你会想要使用“破坏”。|2030298|entityMap^0|1T|E|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|P|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|K|$]]

Basically "delete" sends a query directly to the database to delete the record. In that case Rails doesn't know what attributes are in the record it is deleting nor if there are any callbacks (such as <code>before_destroy</code>).

The "destroy" method takes the passed id, fetches the model from the database using the "find" method, then calls destroy on that. This means the callbacks are triggered.

You would want to use "delete" if you don't want the callbacks to be triggered or you want better performance. Otherwise (and most of the time) you will want to use "destroy".

What is the difference between 

<code>@model.destroy</code> and <code>@model.delete</code> 

For example:

<pre><code>Model.find_by(col: "foo").destroy_all
//and
Model.find_by(col: "foo").delete_all
</code></pre>

Does it really matter if I use the one or the other?

Difference between Destroy and Delete

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

两者有什么区别？@model.destroy和@model.delete例如：Model.find_by(col: "foo").destroy_all//andModel.find_by(col: "foo").delete_all我用这个还是那个真的有关系吗？

问销毁和删除的区别
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问销毁和删除的区别EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问销毁和删除的区别
EN