提炼精华：《JavaScript: The Good Parts》深度解读

需积分: 3 173 浏览量更新于2024-07-22 收藏 1.54MB PDF 举报

《JavaScript: The Good Parts》是一本备受推崇的JavaScript编程经典著作，作者Douglas Crockford以其深入浅出的方式，精选了JavaScript语言中最精华的部分，帮助开发者理解和掌握这门在Web开发中不可或缺的语言。这本书旨在引导读者避开一些复杂和混乱的部分，专注于那些高效、实用且经过精心设计的特性。在《JavaScript: The Good Parts》中，Crockford强调了代码清晰性、可维护性和性能优化的重要性。书中讲解了诸如变量声明提升、严格模式、函数作用域、闭包、原型链以及异步编程等核心概念，这些都是构建健壮JavaScript应用的基础。他还讨论了如何避免常见的陷阱，如全局变量的滥用和错误处理的最佳实践。对于想要深入学习JavaScript的读者来说，除了本书外，O'Reilly出版社提供了丰富的其他资源。例如，High Performance Web Sites、JavaScript and DHTML Cookbook等书籍提供了更全面的前端开发指南，而JavaScript: The Definitive Guide则提供了详尽的技术细节。通过O'Reilly官网（oreilly.com），开发者可以找到最新的技术资讯、文章、博客、样章和代码示例，持续跟进JavaScript语言的发展和最佳实践。 O'Reilly作为一个全球知名的IT出版商，不仅拥有完整的图书目录，还通过oreillynet.com为开发者提供了一个聚焦于开源和新兴技术的平台，包括新平台、编程语言和操作系统等内容。参加O'Reilly组织的会议和研讨会，可以与业界的创新者交流，共同推动技术进步。如果你是程序员或IT专业人员，Safari Bookshelf（safari.oreilly.com）是一个强大的在线参考图书馆，它汇集了超过1000本编程书籍，可以实时搜索并快速找到答案，帮助解决工作中的紧急问题。通过这个数字图书馆，你可以随时随地阅读《JavaScript: The Good Parts》和其他高质量的技术书籍，提高自己的专业技能。《JavaScript: The Good Parts》是一本不可多得的JavaScript入门和进阶读物，它以简洁明了的方式阐述了JavaScript的核心优势和最佳实践，结合O'Reilly丰富的资源库，为学习者和开发者提供了强大的学习工具和持续学习的路径。

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页未读，继续阅读

phoenix203

粉丝: 0
资源: 1

提炼精华：《JavaScript: The Good Parts》深度解读

JavaScript the good parts

JavaScript the good parts 经典课程

适合初学者的javascript相关书籍

javascript相关外文文献

how can i learn javascript

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

nodejs解析xml

typejavascript学习

学习前端有哪些好的书籍

使用Node.js的xml2js模块操作xml数据

最新资源