深入理解JavaScript：异步与性能优化

Dont

Know

需积分: 9 11 浏览量更新于2024-07-19 收藏 3.5MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

"Kyle Simpson的《You Don't Know JS Async & Performance》" 这本书是Kyle Simpson的《You Don't Know JS》系列中的一部分，专注于讲解JavaScript的异步处理和性能优化。作者通过深入浅出的方式，帮助读者理解JavaScript的新特性，如Promise、Generator以及Web Workers，这些工具和技术可以有效地构建复杂的单页应用，并避免回调地狱的问题。 JavaScript是一种广泛使用的编程语言，但即使是有经验的开发者也可能对其某些方面不完全了解。《You Don't Know JS: Async & Performance》针对的就是这些容易被忽视的异步特性和性能提升技巧。通过阅读这本书，读者能够掌握如何更好地处理异步编程，从而提升代码质量和效率。书中的主要内容包括： 1. **探索JavaScript的异步编程方法**：书中涵盖了处理异步操作的各种旧有和新出现的方法，比如传统的回调函数、事件监听器、未来的async/await语法等。 2. **逃离回调地狱**：Promise是解决回调地狱问题的关键，通过Promise链式调用，可以保持代码的可读性和可维护性，同时解决了回调函数嵌套过深导致的问题。 3. **使用Generator进行流程控制**：Generator函数允许在执行过程中暂停和恢复，为异步编程提供了一种新的控制流机制。它们可以用来创建迭代器，使得异步操作变得更加简洁和优雅。 4. **利用Web Workers提升性能**：Web Workers可以在后台线程中执行计算密集型任务，避免阻塞主线程，从而提高网页应用的响应速度。 5. **性能优化策略**：书中还探讨了如何优化JavaScript的运行效率，包括内存管理、代码优化、错误处理以及性能分析工具的使用。 6. **实战示例**：书中包含丰富的实际示例，帮助读者将理论知识应用于实践中，以解决真实世界的问题。通过学习这本书，读者不仅可以深化对JavaScript异步编程的理解，还能提升编写高性能代码的能力，从而成为更全面的JavaScript专家。

资源详情

资源推荐

has always been the humble callback function. Many to this day will

insist that callbacks are more than sufficient.

But as JS continues to grow in both scope and complexity, to meet

the ever-widening demands of a first-class programming language

that runs in browsers and servers and every conceivable device in

between, the pains by which we manage asynchrony are becoming

increasingly crippling, and they cry out for approaches that are both

more capable and more reason-able.

While this all may seem rather abstract right now, I assure you we’ll

tackle it more completely and concretely as we go on through this

book. We’ll explore a variety of emerging techniques for async Java‐

Script programming over the next several chapters.

But before we can get there, we’re going to have to understand

much more deeply what asynchrony is and how it operates in JS.

A Program in Chunks

You may write your JS program in one .js file, but your program is

almost certainly comprised of several chunks, only one of which is

going to execute now, and the rest of which will execute later. The

most common unit of each chunk is the function.

The problem most developers new to JS seem to have is that later

doesn’t happen strictly and immediately after now. In other words,

tasks that cannot complete now are, by definition, going to complete

asynchronously, and thus we will not have blocking behavior as you

might intuitively expect or want.

Consider:

// ajax(..) is some arbitrary Ajax function given by a library

var data = ajax( "http://some.url.1" );

console.log( data );

// Oops! `data` generally won't have the Ajax results

You’re probably aware that standard Ajax requests don’t complete

synchronously, which means the ajax(..) function does not yet

have any value to return back to be assigned to the data variable. If

ajax(..) could block until the response came back, then the data

= .. assignment would work fine.

2 | Chapter 1: Asynchrony: Now & Later

What!? That seems like a crazy claim, right? In fact, it’s quite true.

The JS engine itself has never done anything more than execute a

single chunk of your program at any given moment, when asked to.

“Asked to.” By whom? That’s the important part!

The JS engine doesn’t run in isolation. It runs inside a hosting envi‐

ronment, which is for most developers the typical web browser.

Over the last several years (but by no means exclusively), JS has

expanded beyond the browser into other environments, such as

servers, via things like Node.js. In fact, JavaScript gets embedded

into all kinds of devices these days, from robots to lightbulbs.

But the one common “thread” (that’s a not-so-subtle asynchronous

joke, for what it’s worth) of all these environments is that they have

a mechanism in them that handles executing multiple chunks of

your program over time, at each moment invoking the JS engine,

called the event loop.

In other words, the JS engine has had no innate sense of time, but

has instead been an on-demand execution environment for any

arbitrary snippet of JS. It’s the surrounding environment that has

always scheduled “events” (JS code executions).

So, for example, when your JS program makes an Ajax request to

fetch some data from a server, you set up the response code in a

function (commonly called a callback), and the JS engine tells the

hosting environment, “Hey, I’m going to suspend execution for

now, but whenever you finish with that network request, and you

have some data, please call this function back.”

The browser is then set up to listen for the response from the net‐

work, and when it has something to give you, it schedules the call‐

back function to be executed by inserting it into the event loop.

So what is the event loop?

Let’s conceptualize it first through some fake-ish code:

// `eventLoop` is an array that acts as a queue

// (first-in, first-out)

var eventLoop = [ ];

var event;

// keep going "forever"

while (true) {

// perform a "tick"

if (eventLoop.length > 0) {

6 | Chapter 1: Asynchrony: Now & Later

剩余294页未读，继续阅读

shuafen_bdxl_1

粉丝: 3
资源: 59

深入理解JavaScript：异步与性能优化

Kyle Simpson You Dont Know JS ES6 & Beyond

You Don’t Know JS Async & Performance

js非常详细的思维导图

javaScript相关电子书

javascript参考文献

学JavaScript应该看那些书

用javascript写一个书店网页关于书的热搜榜

rebuild Lakers in NBA2K19

使用python绘制一个简单的NBA人物关系图

javaweb参考文献近五年

关于MongoDB的十条参考文献

sql中group by、having、order by的用法，请举简单例子说明

mongodb的教材

epsanet代码pytorch

二维 注意力机制pytorch

conda install pymongo

两杠是L1 norm

pytorch adam

pycharm安装line_profiler

transformer中AttributeError: 'Namespace' object has no attribute 'frequency_map'

最新资源

二维注意力机制pytorch