深入理解JavaScript的精华部分

需积分: 10 7 浏览量更新于2024-07-21 收藏 1.53MB PDF 举报

"JavaScript the Good Parts 是一本关于JavaScript编程的书籍，主要探讨了JavaScript语言的优秀部分，由O'Reilly出版社出版。这本书可能是对JavaScript语言深入理解和高效应用的指南，涵盖了核心概念、最佳实践和可能的陷阱。" JavaScript是目前互联网开发中最广泛使用的脚本语言之一，它使得网页变得更加动态和交互性更强。"JavaScript The Good Parts" 这本书很可能专注于讨论JavaScript语言的精华部分，帮助读者避开语言的一些常见问题和陷阱，同时提高他们的编程技能。在JavaScript中，“好部分”可能包括但不限于以下几个方面： 1. **变量和数据类型**：JavaScript支持动态类型，这意味着变量可以在运行时改变其数据类型。理解基本数据类型（如Number、String、Boolean、Null、Undefined）和复杂数据类型（如Object和Array）的用法是基础。 2. **函数**：JavaScript的函数不仅是代码块，还可以作为值传递，这使得函数式编程成为可能。闭包和作用域的概念也至关重要，它们对于内存管理和模块化设计有直接影响。 3. **原型和继承**：JavaScript使用原型链实现对象的继承，这是一种不同于其他面向对象语言的机制。理解如何通过原型进行属性共享和方法继承是关键。 4. **事件处理**：JavaScript与DOM（文档对象模型）交互，用于创建用户界面的动态效果和响应用户操作。事件监听和事件冒泡是这部分的核心。 5. **异步编程**：JavaScript的非阻塞特性使得它可以处理大量的I/O操作而不会阻塞浏览器。回调函数、Promise和async/await等技术是处理异步任务的关键。 6. **ES6及以后的更新**：自JavaScript诞生以来，它不断演进，引入了很多新特性，如箭头函数、模板字符串、解构赋值、类和模块系统等，这些都是现代JavaScript开发的重要组成部分。 7. **性能优化**："High Performance Web Sites"这个标签暗示了书中可能涉及如何利用JavaScript优化网页性能，如减少HTTP请求、合理使用缓存、避免阻塞渲染等策略。 8. **错误处理**：理解如何有效地捕获和处理错误是编写健壮JavaScript代码的关键。try...catch语句、throw语句以及错误对象的使用都是重要的知识点。 9. **调试和测试**：有效的调试技巧和自动化测试工具可以帮助开发者找到并修复代码中的问题，确保软件的质量。 10. **安全性**：JavaScript还涉及网络安全问题，如跨站脚本攻击(XSS)和跨站请求伪造(CSRF)等，了解这些安全风险并知道如何防止它们是必要的。通过阅读"JavaScript The Good Parts"，开发者可以深入理解JavaScript的这些核心概念，并学会如何在实际项目中有效应用。此外，O'Reilly出版社还提供了其他相关书籍和资源，如"JavaScript and DHTML Cookbook"，"JavaScript: The Definitive Guide"和"Learning JavaScript"，这些都可以作为深入学习JavaScript的补充材料。访问O'Reilly的网站，你可以找到更多相关的新闻、事件、文章、博客、样本章节和代码示例，进一步扩展你的知识库。同时，O'Reilly的Safari Bookshelf在线参考图书馆提供超过1000本书的搜索和即时访问，对于程序员和IT专业人员来说是一个宝贵的资源。

Chapter 1

CHAPTER 1

Good Parts1

…setting the attractions of my

good parts aside I have no other charms.

—William Shakespeare, The Merry Wives of Windsor

When I was a young journeyman programmer, I would learn about every feature of

the languages I was using, and I would attempt to use all of those features when I

wrote. I suppose it was a way of showing off, and I suppose it worked because I was

the guy you went to if you wanted to know how to use a particular feature.

Eventually I figured out that some of those features were more trouble than they

were worth. Some of them were poorly specified, and so were more likely to cause

portability problems. Some resulted in code that was difficult to read or modify. Some

induced me to write in a manner that was too tricky and error-prone. And some of

those features were design errors. Sometimes language designers make mistakes.

Most programming languages contain good parts and bad parts. I discovered that I

could be a better programmer by using only the good parts and avoiding the bad

parts. After all, how can you build something good out of bad parts?

It is rarely possible for standards committees to remove imperfections from a lan-

guage because doing so would cause the breakage of all of the bad programs that

depend on those bad parts. They are usually powerless to do anything except heap

more features on top of the existing pile of imperfections. And the new features do

not always interact harmoniously, thus producing more bad parts.

But you have the power to define your own subset. You can write better programs by

relying exclusively on the good parts.

JavaScript is a language with more than its share of bad parts. It went from non-

existence to global adoption in an alarmingly short period of time. It never had an

interval in the lab when it could be tried out and polished. It went straight into

Netscape Navigator 2 just as it was, and it was very rough. When Java™ applets

failed, JavaScript became the “Language of the Web” by default. JavaScript’s popu-

larity is almost completely independent of its qualities as a programming language.

Chapter 1: Good Parts

Fortunately, JavaScript has some extraordinarily good parts. In JavaScript, there is a

beautiful, elegant, highly expressive language that is buried under a steaming pile of

good intentions and blunders. The best nature of JavaScript is so effectively hidden

that for many years the prevailing opinion of JavaScript was that it was an unsightly,

incompetent toy. My intention here is to expose the goodness in JavaScript, an out-

standing, dynamic programming language. JavaScript is a block of marble, and I chip

away the features that are not beautiful until the language’s true nature reveals itself.

I believe that the elegant subset I carved out is vastly superior to the language as a

whole, being more reliable, readable, and maintainable.

This book will not attempt to fully describe the language. Instead, it will focus on the

good parts with occasional warnings to avoid the bad. The subset that will be

described here can be used to construct reliable, readable programs small and large.

By focusing on just the good parts, we can reduce learning time, increase robustness,

and save some trees.

Perhaps the greatest benefit of studying the good parts is that you can avoid the need

to unlearn the bad parts. Unlearning bad patterns is very difficult. It is a painful task

that most of us face with extreme reluctance. Sometimes languages are subsetted to

make them work better for students. But in this case, I am subsetting JavaScript to

make it work better for professionals.

Why JavaScript?

JavaScript is an important language because it is the language of the web browser. Its

association with the browser makes it one of the most popular programming lan-

guages in the world. At the same time, it is one of the most despised programming

languages in the world. The API of the browser, the Document Object Model

(DOM) is quite awful, and JavaScript is unfairly blamed. The DOM would be pain-

ful to work with in any language. The DOM is poorly specified and inconsistently

implemented. This book touches only very lightly on the DOM. I think writing a

Good Parts book about the DOM would be extremely challenging.

JavaScript is most despised because it isn’t some other language. If you are good in

some other language and you have to program in an environment that only supports

JavaScript, then you are forced to use JavaScript, and that is annoying. Most people

in that situation don’t even bother to learn JavaScript first, and then they are sur-

prised when JavaScript turns out to have significant differences from the some other

language they would rather be using, and that those differences matter.

The amazing thing about JavaScript is that it is possible to get work done with it

without knowing much about the language, or even knowing much about program-

ming. It is a language with enormous expressive power. It is even better when you

know what you’re doing. Programming is difficult business. It should never be

undertaken in ignorance.

Analyzing JavaScript

JavaScript is built on some very good ideas and a few very bad ones.

The very good ideas include functions, loose typing, dynamic objects, and an expres-

sive object literal notation. The bad ideas include a programming model based on

global variables.

JavaScript’s functions are first class objects with (mostly) lexical scoping. JavaScript

is the first lambda language to go mainstream. Deep down, JavaScript has more in

common with Lisp and Scheme than with Java. It is Lisp in C’s clothing. This makes

JavaScript a remarkably powerful language.

The fashion in most programming languages today demands strong typing. The the-

ory is that strong typing allows a compiler to detect a large class of errors at compile

time. The sooner we can detect and repair errors, the less they cost us. JavaScript is a

loosely typed language, so JavaScript compilers are unable to detect type errors. This

can be alarming to people who are coming to JavaScript from strongly typed lan-

guages. But it turns out that strong typing does not eliminate the need for careful

testing. And I have found in my work that the sorts of errors that strong type check-

ing finds are not the errors I worry about. On the other hand, I find loose typing to

be liberating. I don’t need to form complex class hierarchies. And I never have to cast

or wrestle with the type system to get the behavior that I want.

JavaScript has a very powerful object literal notation. Objects can be created simply

by listing their components. This notation was the inspiration for JSON, the popu-

lar data interchange format. (There will be more about JSON in Appendix E.)

A controversial feature in JavaScript is prototypal inheritance. JavaScript has a class-

free object system in which objects inherit properties directly from other objects. This

is really powerful, but it is unfamiliar to classically trained programmers. If you attempt

to apply classical design patterns directly to JavaScript, you will be frustrated. But if

you learn to work with JavaScript’s prototypal nature, your efforts will be rewarded.

JavaScript is much maligned for its choice of key ideas. For the most part, though,

those choices were good, if unusual. But there was one choice that was particularly

bad: JavaScript depends on global variables for linkage. All of the top-level variables

of all compilation units are tossed together in a common namespace called the global

object. This is a bad thing because global variables are evil, and in JavaScript they are

fundamental. Fortunately, as we will see, JavaScript also gives us the tools to miti-

gate this problem.

In a few cases, we can’t ignore the bad parts. There are some unavoidable awful

parts, which will be called out as they occur. They will also be summarized in

Appendix A. But we will succeed in avoiding most of the bad parts in this book,

summarizing much of what was left out in Appendix B. If you want to learn more

about the bad parts and how to use them badly, consult any other JavaScript book.

Chapter 1: Good Parts

The standard that defines JavaScript (aka JScript) is the third edition of The

ECMAScript Programming Language, which is available from http://www.ecma-

international.org/publications/files/ecma-st/ECMA-262.pdf. The language described in

this book is a proper subset of ECMAScript. This book does not describe the whole

language because it leaves out the bad parts. The treatment here is not exhaustive. It

avoids the edge cases. You should, too. There is danger and misery at the edges.

Appendix C describes a programming tool called JSLint, a JavaScript parser that can

analyze a JavaScript program and report on the bad parts that it contains. JSLint pro-

vides a degree of rigor that is generally lacking in JavaScript development. It can give

you confidence that your programs contain only the good parts.

JavaScript is a language of many contrasts. It contains many errors and sharp edges,

so you might wonder, “Why should I use JavaScript?” There are two answers. The

first is that you don’t have a choice. The Web has become an important platform for

application development, and JavaScript is the only language that is found in all

browsers. It is unfortunate that Java failed in that environment; if it hadn’t, there

could be a choice for people desiring a strongly typed classical language. But Java did

fail and JavaScript is flourishing, so there is evidence that JavaScript did something

right.

The other answer is that, despite its deficiencies, JavaScript is really good. It is light-

weight and expressive. And once you get the hang of it, functional programming is a

lot of fun.

But in order to use the language well, you must be well informed about its limita-

tions. I will pound on those with some brutality. Don’t let that discourage you. The

good parts are good enough to compensate for the bad parts.

A Simple Testing Ground

If you have a web browser and any text editor, you have everything you need to run

JavaScript programs. First, make an HTML file with a name like program.html:

</script></pre></body></html>

Then, make a file in the same directory with a name like program.js:

document.writeln('Hello, world!');

Next, open your HTML file in your browser to see the result. Throughout the book,

method method is used to define new methods. This is its definition:

Function.prototype.method = function (name, func) {

this.prototype[name] = func;

return this;

};

It will be explained in Chapter 4.

剩余171页未读，继续阅读

baidu_26416601

粉丝: 0
资源: 1

深入理解JavaScript的精华部分

JavaScript the good parts 经典课程

JavaScript the good parts

JavaScript语言精粹 修订版 中文高清PDF 带书签 JavaScript The Good Parts .rar

适合初学者的javascript相关书籍

how can i learn javascript

javascript相关外文文献

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

nodejs解析xml

typejavascript学习

学习前端有哪些好的书籍

最新资源

JavaScript语言精粹修订版中文高清PDF 带书签 JavaScript The Good Parts .rar