Eloquent JavaScript第三版：深度探索编程艺术

JavaSc

需积分: 10 195 浏览量更新于2024-07-17 收藏 2.16MB PDF 举报

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

领优惠券(最高得80元）

"Eloquent JavaScript 3rd edition" 是一本由 Marijn Haverbeke 撰写的关于 JavaScript 编程的书籍，采用创作共用署名非商业许可协议，并且书中的代码也遵循 MIT 许可协议。这本书分为三个部分，深入介绍了语言本身、浏览器环境下的应用以及 Node.js 开发。在第一部分（语言）中，作者详细讲解了以下知识点： 1. **值、类型和操作符**：讨论了 JavaScript 的基本数据类型（如字符串、数字、布尔值、null 和 undefined），以及操作符（算术、比较和逻辑操作符）的使用。 2. **程序结构**：涵盖了条件语句（if、switch）、循环（for、while）以及如何通过流程控制构造复杂的程序结构。 3. **函数**：阐述了函数的定义、参数传递、作用域和闭包等概念，以及如何利用函数作为一等公民进行编程。 4. **数据结构：对象和数组**：详细解释了对象的属性和方法，以及数组的索引和操作，强调了它们在 JavaScript 中的重要性。 5. **高阶函数**：讨论了函数可以作为值传递、作为返回值和作为参数，以及如何使用数组方法（如 map、reduce 和 filter）来处理数据。 6. **对象的秘密生活**：深入探讨了原型链和继承机制，以及如何通过构造函数和原型创建类的模拟。 7. **项目：一个机器人**：提供了一个实际的编程项目，帮助读者实践所学的知识。 8. **错误和调试**：讲解了如何识别和修复程序中的错误，以及调试技巧。 9. **正则表达式**：介绍了正则表达式的语法和模式匹配，包括量词、分组和捕获等高级特性。 10. **模块**：讨论了如何组织代码，以及 CommonJS 和 ES6 模块系统的工作原理。 11. **异步编程**：涵盖了回调函数、Promise 和 async/await，帮助理解 JavaScript 中的非阻塞执行。 12. **项目：一个编程语言**：提供了一个构建小型编程语言的项目，进一步巩固语言设计和实现的概念。第二部分（浏览器）专注于 JavaScript 在浏览器环境中的应用： 1. **JavaScript 和浏览器**：讲解了 JavaScript 如何与浏览器交互，以及浏览器如何执行 JavaScript 代码。 2. **文档对象模型（DOM）**：详细介绍了 DOM 的结构和操作，包括元素选择、属性访问和事件处理。 3. **事件处理**：讨论了事件冒泡、事件委托和如何编写事件处理函数。 4. **项目：平台游戏**：提供了一个使用 DOM 和事件编程实现的游戏项目。 5. **Canvas 绘图**：介绍了如何使用 HTML5 的 Canvas 元素进行图形绘制。 6. **HTTP 和表单**：讲解了 HTTP 协议基础和如何使用 JavaScript 处理表单提交。 7. **项目：像素艺术编辑器**：通过 Canvas 实现一个简单的像素艺术编辑工具。第三部分（Node.js）则关注服务器端开发： 1. **Node.js**：介绍了 Node.js 的基础知识，包括事件驱动、非阻塞 I/O 和模块系统。 2. **项目：技能分享网站**：提供了一个使用 Node.js 构建的 Web 应用程序项目。这本书全面覆盖了 JavaScript 语言的基础和进阶知识，适合初学者和有一定经验的开发者阅读，旨在提升编程技能并深入理解 JavaScript 的工作原理。

资源详情

资源推荐

1. Store the number 0 in memory location 0.

2. Store the number 1 in memory location 1.

3. Store the value of memory location 1 in memory location 2.

4. Subtract the number 11 from the value in memory location 2.

5. If the value in memory location 2 is the number 0, continue with instruc-

tion 9.

6. Add the value of memory location 1 to memory location 0.

7. Add the number 1 to the value of memory location 1.

8. Continue with instruction 3.

9. Output the value of memory location 0.

Although that is already more readable than the soup of bits, it is still rather

obscure. Using names instead of numbers for the instructions and memory

locations helps.

Set “total” to 0.

Set “count” to 1.

[loop]

Set “compare” to “count”.

Subtract 11 from “compare”.

If “compare” is zero, continue at [end].

Add “count” to “total”.

Add 1 to “count”.

Continue at [loop].

[end]

Output “total”.

Can you see how the program works at this point? The rst two lines give

two memory locations their starting values: total will be used to build up the

result of the computation, and count will keep track of the number that we are

currently looking at. The lines using compare are probably the weirdest ones.

The program wants to see whether count is equal to 11 to decide whether it

can stop running. Because our hypothetical machine is rather primitive, it can

only test whether a number is zero and make a decision based on that. So it

uses the memory location labeled compare to compute the value of count - 11

and makes a decision based on that value. The next two lines add the value

What is JavaScript?

JavaScript was introduced in 1995 as a way to add programs to web pages in the

Netscape Navigator browser. The language has since been adopted by all other

major graphical web browsers. It has made modern web applications possible—

applications with which you can interact directly without doing a page reload

for every action. JavaScript is also used in more traditional websites to provide

various forms of interactivity and cleverness.

It is important to note that JavaScript has almost nothing to do with the

programming language named Java. The similar name was inspired by mar-

keting considerations rather than good judgment. When JavaScript was being

introduced, the Java language was being heavily marketed and was gaining

popularity. Someone thought it was a good idea to try to ride along on this

success. Now we are stuck with the name.

After its adoption outside of Netscape, a standard document was written

to describe the way the JavaScript language should work so that the various

pieces of software that claimed to support JavaScript were actually talking

about the same language. This is called the ECMAScript standard, after the

Ecma International organization that did the standardization. In practice, the

terms ECMAScript and JavaScript can be used interchangeably—they are two

names for the same language.

There are those who will say terrible things about JavaScript. Many of these

things are true. When I was required to write something in JavaScript for the

rst time, I quickly came to despise it. It would accept almost anything I typed

but interpret it in a way that was completely dierent from what I meant. This

had a lot to do with the fact that I did not have a clue what I was doing, of

course, but there is a real issue here: JavaScript is ridiculously liberal in what

it allows. The idea behind this design was that it would make programming in

JavaScript easier for beginners. In actuality, it mostly makes nding problems

in your programs harder because the system will not point them out to you.

This exibility also has its advantages, though. It leaves space for a lot of

techniques that are impossible in more rigid languages, and as you will see

(for example in Chapter 10), it can be used to overcome some of JavaScript’s

shortcomings. After learning the language properly and working with it for a

while, I have learned to actually like JavaScript.

There have been several versions of JavaScript. ECMAScript version 3 was

the widely supported version in the time of JavaScript’s ascent to dominance,

roughly between 2000 and 2010. During this time, work was underway on

an ambitious version 4, which planned a number of radical improvements and

extensions to the language. Changing a living, widely used language in such a

radical way turned out to be politically dicult, and work on the version 4 was

abandoned in 2008, leading to a much less ambitious version 5, which made

only some uncontroversial improvements, coming out in 2009. Then in 2015

version 6 came out, a major update that included some of the ideas planned

for version 4. Since then we’ve had new, small updates every year.

The fact that the language is evolving means that browsers have to constantly

keep up, and if you’re using an older browser, it may not support every feature.

The language designers are careful to not make any changes that could break

existing programs, so new browsers can still run old programs. In this book,

I’m using the 2017 version of JavaScript.

Web browsers are not the only platforms on which JavaScript is used. Some

databases, such as MongoDB and CouchDB, use JavaScript as their scripting

and query language. Several platforms for desktop and server programming,

most notably the Node.js project (the subject of Chapter 20), provide an envi-

ronment for programming JavaScript outside of the browser.

Code, and what to do with it

Code is the text that makes up programs. Most chapters in this book contain

quite a lot of code. I believe reading code and writing code are indispensable

parts of learning to program. Try to not just glance over the examples—read

them attentively and understand them. This may be slow and confusing at

rst, but I promise that you’ll quickly get the hang of it. The same goes for

the exercises. Don’t assume you understand them until you’ve actually written

a working solution.

I recommend you try your solutions to exercises in an actual JavaScript

interpreter. That way, you’ll get immediate feedback on whether what you are

doing is working, and, I hope, you’ll be tempted to experiment and go beyond

the exercises.

The easiest way to run the example code in the book, and to experiment with

it, is to look it up in the online version of the book at https://eloquentjavascript.net.

There, you can click any code example to edit and run it and to see the output

it produces. To work on the exercises, go to https://eloquentjavascript.net/

code, which provides starting code for each coding exercise and allows you to

look at the solutions.

If you want to run the programs dened in this book outside of the book’s

website, some care will be required. Many examples stand on their own and

should work in any JavaScript environment. But code in later chapters is

often written for a specic environment (the browser or Node.js) and can run

only there. In addition, many chapters dene bigger programs, and the pieces

of code that appear in them depend on each other or on external les. The

sandbox on the website provides links to Zip les containing all the scripts and

data les necessary to run the code for a given chapter.

Overview of this book

This book contains roughly three parts. The rst 12 chapters discuss the

JavaScript language. The next seven chapters are about web browsers and the

way JavaScript is used to program them. Finally, two chapters are devoted to

Node.js, another environment to program JavaScript in.

Throughout the book, there are ve project chapters, which describe larger

example programs to give you a taste of actual programming. In order of

appearance, we will work through building a delivery robot, a programming

language, a platform game, a pixel paint program, and a dynamic website.

The language part of the book starts with four chapters that introduce the

basic structure of the JavaScript language. They introduce control structures

(such as the while word you saw in this introduction), functions (writing your

own building blocks), and data structures. After these, you will be able to write

basic programs. Next, Chapters 5 and 6 introduce techniques to use functions

and objects to write more abstract code and keep complexity under control.

After a rst project chapter, the language part of the book continues with

chapters on error handling and bug xing, regular expressions (an important

tool for working with text), modularity (another defense against complexity),

and asynchronous programming (dealing with events that take time). The

second project chapter concludes the rst part of the book.

The second part, Chapters 13 to 19, describes the tools that browser JavaScript

has access to. You’ll learn to display things on the screen (Chapters 14 and

17), respond to user input (Chapter 15), and communicate over the network

(Chapter 18). There are again two project chapters in this part.

After that, Chapter 20 describes Node.js, and Chapter 21 builds a small

website using that tool.

Typographic conventions

In this book, text written in a monospaced font will represent elements of

programs—sometimes they are self-sucient fragments, and sometimes they

just refer to part of a nearby program. Programs (of which you have already

seen a few) are written as follows:

剩余447页未读，继续阅读

nyckevin

粉丝: 0
资源: 2

Eloquent JavaScript第三版：深度探索编程艺术

Eloquent-JavaScript-Exercises:我对Marijn Haverbeke的Eloquent JavaScript（第2版）中的练习的解决方案

Eloquent JavaScript.epub 电子书

Eloquent JavaScript 3rd Edition (True PDF)

how can i learn javascript

html,css,javascript,node.js,Mysql数据库的参考文献

二手房数据爬取参考文献

JavaScript的英文文献引用

适合初学者的javascript相关书籍

laravel 5.5 eloquent文档

给我找点js的学习资料

laravel Eloquent 分组查询

ros2 cartographer eloquent

php分组统计,Laravel 实现Eloquent模型分组查询并返回每个分组的数量 groupBy()

js非常详细的思维导图

Illuminate\Database\Eloquent\Collection

关于vue的外文文献参考

make a story about 'eloquent'

laravel中的Eloquent\Builder::macro

Ubuntu18.04 ros-eloquent如何安装turtlebot3-gazebo

ros-eloquent-desktop与ros-dashing-desktop啥区别

最新资源