blocks|key|2922595|text|维基百科对延迟加载的定义是计算机编程中常用的一种设计模式，它将对象的初始化推迟到需要它的时候。..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2922596|http://en.wikipedia.org/wiki/Lazy%2520loading|offset|length|2922597|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Lazy%2520loading^0|0|0|17|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

wikipedia's Definition
Lazy loading is a design pattern commonly used in computer programming to defer initialization of an object until the point at which it is needed. ...

<a href="http://en.wikipedia.org/wiki/Lazy%20loading" rel="noreferrer">http://en.wikipedia.org/wiki/Lazy%20loading</a>

blocks|key|5177886|text|延迟加载是一种编程实践，只在第一次需要对象时才加载或初始化该对象。这可能会给你带来很大的性能提升，特别是当你的应用程序中有很多组件的时候。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5177887|像往常一样，Wikipedia有更多细节。|offset|length|5177888|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Lazy_loading^0|0|6|9|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Lazy Loading is a programming practice in which you only load or initialize an object when you first need it. This can potentially give you a big performance boost, especially if you have a lot of components in your application.

As usual, <a href="http://en.wikipedia.org/wiki/Lazy_loading" rel="noreferrer">Wikipedia</a> has more details.

blocks|key|3767305|text|下面是我编写的一些实际Python代码中的一个示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3767306|class+Item(Model):
++++...
++++@property
++++def+total(self):
++++++++if+not+hasattr(self,+"_total"):
++++++++++++self._total+=+self.quantity+\
++++++++++++++++++%2B+sum(bi.quantity+for+bi+in+self.borroweditem_set.all())
++++++++return+self._total|code-block|syntax|javascript|3767307|基本上，我有一个Item类，它表示我们库存中的一个项目。我们拥有的物品总数是我们拥有的数量加上我们从各种来源借来的所有物品的总和。这些数字都存储在我们的数据库中，在实际请求总数之前，计算这些数字是没有意义的(因为通常会使用没有请求总数的项目)。|3767308|因此，total属性检查_total字段是否存在。如果没有，那么属性代码将查询数据库并计算它，然后将值存储在_total字段中，这样下次请求它时就不需要重新计算它了。|3767309|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Here's an example from some actual Python code I wrote:

<pre><code>class Item(Model):
 ...
 @property
 def total(self):
 if not hasattr(self, "_total"):
 self._total = self.quantity \
 + sum(bi.quantity for bi in self.borroweditem_set.all())
 return self._total
</code></pre>

Basically, I have an Item class which represents an item in our inventory. The total number of items we have is the number that we own plus the sum of all of the items that we're borrowing from various sources. These numbers are all stored in our database, and it would be pointless to calculate this until the total is actually requested (since often Items will be used without the total being requested).

So the total property checks whether the _total field exists. If it doesn't, then the property code queries the database and computes it, then stores the value in the _total field so that it need not be recomputed the next time it's requested.

blocks|key|2922847|text|这就是所谓的延迟加载，因为就像一个懒惰的人一样，你正在推迟做一些你不想做的事情。相反的是急切加载，在你需要之前很久，你就立即加载了一些东西。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2922848|如果你很好奇为什么人们会使用延迟加载，考虑一个需要很长时间才能启动的应用程序。这个应用程序可能正在进行大量的紧急加载...从磁盘加载东西，并在需要之前不久做计算和其他事情。|2922849|与延迟加载相比，应用程序的启动速度会快得多，但是当您第一次需要执行一些需要长时间运行负载的操作时，在第一次加载时可能会有轻微的停顿。因此，使用延迟加载，您可以在运行应用程序的整个过程中分摊加载时间……实际上，您可以从加载用户可能永远不会使用的内容中节省下来。|2922850|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

It's called lazy loading because, like a lazy person, you are putting off doing something you don't want to. The opposite is Eager Loading, where you load something right away, long before you need it.

If you are curious why people might use lazy loading, consider an application that takes a LOOOOONG time to start. This application is probably doing a lot of eager loading... loading things from disk, and doing calculations and whatnot long before it is ever needed.

Compare this to lazy loading, the application would start much faster, but then the first time you need to do something that requires some long running load, there may be a slight pause while it is loaded for the first time. Thus, with lazy loading, you are amortizing the load time throughout the course of running your application... and you may actually save from loading things that the user may never intend to use.

blocks|key|2922973|text|术语惰性加载通常在谈论对象关系映射器时使用。如果你直接使用ADO.NET，你总是会立即加载(即它总是加载你指定的内容)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2922974|或者，像nHibernate这样的映射器支持返回代理对象，只有当您访问数据时，这些代理对象才会被正确的数据“填充”。这样你就只加载了你真正用到的数据。当您指定可以从数据库加载的对象之间的大量关系时，这是一个有用的功能，您不希望OR映射器加载所有相关对象以及与相关对象相关的对象等等。这可能会导致加载整个数据库。|2922975|这个问题也可以通过仔细设计你的对象模型来避免。(使用聚合并像域驱动设计中那样只加载聚合根是一种在不使用延迟加载的情况下绕过此问题的方法)。|2922976|延迟加载可能会导致或映射器执行大量小型数据库访问，而不是一次检索所需的所有数据。这也可能导致性能问题。|2922977|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

The term lazy loading is usually used when talking about object relational mappers. If you use ADO.NET directly you always get eager loading (ie it always loads just what you specify).

OR-mappers like nHibernate support returning proxy objects that get "filled in" with the right data only when you access the data. That way you only load the data that you really use. This is a usefull feature when you specify a lot of relations between objects that can get loaded from the database, you don't want the OR-mapper to load all the related objects and the objects related to the related objects and so on. That can result in your whole database getting loaded.

This problem can be prevented by carefull design of your object model too. (using aggregates and only loading aggregate roots like in domain driven design is a way to get around this without using lazy loading).

Lazy loading can result in the or mapper doing lots of small database accesses instead of retrieving all the data you need once. This can result in performance problems too.

blocks|key|2923025|text|是一种设计模式。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2923026|延迟加载:直到您的代码需要由特定对象完成某些操作之前，对象都不会初始化，一旦初始化，它就不会重新初始化对象，而是使用先前初始化的对象。|2923027|这将使您的代码更有效率，并有助于管理内存使用。|2923028|延迟加载的示例应用程序：|2923029|Ghost+Lazy初始化值持有者|2923030|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

is a Design pattern.

Lazy loading: Untill your code require some operation done by a particular object, object is not initilaized, and once it's initialized it doesn't re-initialize the object but uses the previously initialized object.

This makes your code much more efficient and helps managing memory usage.

Example Applications of Lazy loading:

Ghost
Lazy initialization
Value holder

blocks|key|3767704|text|延迟加载:您不会将时间(或内存)浪费在您可能不需要的东西上。然后当你需要它时，它需要更长的时间，但这是很好的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3767705|生活中的例子:当你需要的时候，你可以一次学习一个短语，而不是真正学习法语的短语手册。这在什么时候是有意义的？如果你只打算在法国待很短一段时间(也就是说，你不需要很多短语)，或者如果你很快就要离开。如果你在那里呆了两年，或者你有很长的时间要学习，那么提前学习整个短语手册(热切加载)可能会更有效率。|3767706|[灵感来自Atom+as+taught+in+gang+terms+by+Venus+on+WKRP。]|offset|length|3767707|entityMap|0|LINK|mutability|MUTABLE|url|http://web.mac.com/scifione/orig/CHEM-HELP/MISC/atom-by-Venus.htm^0|0|0|5|19|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

Lazy loading: you don't waste your time (nor your memory) with stuff you might not need. Then when you need it, it takes longer, but that's fine. 

Example from life: instead of actually learning that French phrasebook, you learn the phrases one at a time, as they're needed. When does this make sense? If you're only going to be in France for a short time (i.e., you won't need a lot of the phrases) or if you need to leave very soon. If you're there for two years and/or you have a long time to study, then it might be much more efficient to just learn the whole phrasebook up front (eager loading).

[Inspired by the <a href="http://web.mac.com/scifione/orig/CHEM-HELP/MISC/atom-by-Venus.htm" rel="nofollow noreferrer">Atom as taught in gang terms by Venus on WKRP</a>.]

blocks|key|5178351|text|惰性加载是数据库中经常使用的一个术语，指的是仅在需要时加载所需信息的部分的概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5178352|也就是说，假设你需要有一条包含多个表的连接的记录。如果您一次获取所有内容，则所需时间将比仅获取主表所需的时间更长。使用延迟加载，剩余的信息将只在需要时才会被获取。因此，在某些情况下，它实际上是“高效加载”。|5178353|其他类型的“加载”是：|5178354|5178355|紧急加载-一次加载所有连接的表。|ordered-list-item|5178356|5178357|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|O|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|Q|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|L|$]]

Lazy loading is a term frequently used in databases to refer to the concept of loading parts of the required info only when it's needed.

I.e. suppose you needed to have a record which has a join of several tables. If you fetched it all at once it would take longer than if you would fetch say only the main table. Using lazy-loading the rest of the information will be fetched only if it is needed. So it is actually 'efficient-loading' in certain scenarios.

The other types of 'loading' is:

<ol>
<li>Eager Loading - Loading all the connected tables at once.</li>
</ol>

blocks|key|5178398|text|Lazy现在是c#+4.0的一部分-在MSDN上有一个很好的页面解释了这个概念。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5178399|entityMap|0|LINK|mutability|MUTABLE|url|http://msdn.microsoft.com/en-us/library/dd642331(VS.100).aspx|1|http://msdn.microsoft.com/en-us/library/dd997286(VS.100).aspx^0|0|4|0|4|0|J|4|1|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]|$9|V|A|W|1|X]]|E|$]]|$1|F|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]|N|$5|I|J|K|E|$L|O]]]]

<a href="http://msdn.microsoft.com/en-us/library/dd642331(VS.100).aspx" rel="nofollow noreferrer"><code>Lazy&lt;T&gt;</code></a> is now part of c# 4.0 - there is a nice page on <a href="http://msdn.microsoft.com/en-us/library/dd997286(VS.100).aspx" rel="nofollow noreferrer">MSDN</a> which explains the concept.

blocks|key|3767943|text|惰性加载的一个例子是在网页上有大量数据要查看的网格或表格，其中应用程序只加载当时用户浏览器的视点大小。当他们向下滚动想要查看更多内容或数据时，此时会有更多数据加载到视图中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3767944|通过ajax或jQuery，这也越来越成为一种常见的可视化/交互设计模式。|3767945|如上所述，相反的是，在不考虑客户端的情况下会急切加载，因此可能会有性能影响。|3767946|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

An example of Lazy Loading would be a grid or table with lots of data on a webpage to view where the application only loads what the users browser viewpoint size is at that time. When they scroll down to want to view more content or data, more data would be loaded into view at that moment.

This is becoming more of a common visual/interaction design pattern as well via ajax or jQuery.

And as mentioned above, opposite would be Eager Loading where you don't take client into consideration thus potentially having a performance hit.

blocks|key|5178620|text|延迟加载是一个概念，在这个概念中，我们将对象单元的加载延迟到需要它的位置。简单地说就是按需加载对象，而不是不必要地加载对象。例如，如果您有一个聚合了"Orders“对象的"Customer”类。因此，您希望加载客户数据，但希望延迟到应用程序需要它时才加载orders对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5178621|下面是一个youtube视频，演示了如何使用延迟加载，我们如何实现延迟加载，以及相同的优点和缺点。|5178622|http://www.youtube.com/watch?v=2SrfdAkwmFo|offset|length|5178623|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|16|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@$F|R|G|S|1|T]]|A|$]]|$1|H|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|E]]]]

Lazy loading is a concept where we delay the loading of the object unit the point where we need it. Putting in simple words on demand object loading rather than loading the objects unnecessarily. For instance if you have a "Customer" class which has "Orders" object aggregated. So you like to load the customer data but the orders objects you would like to delay until your application needs it. 

Below is a youtube video which demonstrates how to use lazy loading , how we can implement lazy loading and advantages and disadvantages of the same.

<a href="http://www.youtube.com/watch?v=2SrfdAkwmFo" rel="noreferrer">http://www.youtube.com/watch?v=2SrfdAkwmFo</a>

blocks|key|3768121|text|延迟加载的一些优点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3768122|由于避免了对服务器的按需loading.|3768123|Unnecessary请求，因此|unordered-list-item|3768124|最大限度地缩短了loading.|ordered-list-item|3768125|Unnecessary的启动时间消耗了更少的内存。|3768126|3768127|3768128|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|R|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|S|8|@]|9|@]|A|$]]|$1|J|3|K|5|I|7|T|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|O|$]]

Some of the advantages of lazy loading:

<ol>
<li>Minimizes start up time of the application.</li>
<li>Application consumes less memory because of on-demand loading.</li>
<li>Unnecessary request to server is avoided.</li>
</ol>

blocks|key|719525|text|根据geeksforgeek的说法，延迟加载是一种软件设计模式，其中对象的初始化只在实际需要时发生，而不是在此之前发生，以保持使用的简单性和提高性能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|719526|https://www.geeksforgeeks.org/lazy-loading-design-pattern/|offset|length|719527|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|1M|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@$D|O|E|P|1|Q]]|A|$]]|$1|F|3|-4|5|6|7|R|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|C]]]]

According to geeksforgeeks, Lazy loading is a software design pattern where the initialization of an object occurs only when it is actually needed and not before to preserve the simplicity of usage and improve performance.

<a href="https://www.geeksforgeeks.org/lazy-loading-design-pattern/" rel="nofollow noreferrer">https://www.geeksforgeeks.org/lazy-loading-design-pattern/</a>

What is Lazy Loading?

[Edit after reading a few answers]
Why do people use this term so often? 

Say you just use a ASP/ADO recordset and load it with data or ADO.NET Datasource for a gridview.

I guess I should have asked why people use the term Lazy Loading, what "other" types are their?

What is Lazy Loading?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

什么是延迟加载？读完几个答案后编辑为什么人们经常使用这个术语？假设您只使用一个ASP/ADO记录集，并将其与网格视图的数据或ADO.NET数据源一起加载。我想我应该问为什么人们使用延迟加载这个术语，他们的“其他”类型是什么？

问什么是延迟加载？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么是延迟加载？EN