精华版JavaScript:提升性能的实用指南

需积分: 13 63 浏览量更新于2024-07-19 收藏 1.48MB PDF 举报

《JavaScript: The Good Parts》是一本由Douglas Crockford撰写的专业英文版JavaScript指南。这本书聚焦于JavaScript语言中最精华、最具实践价值的部分，帮助开发者理解和掌握那些既强大又高效的关键特性。Crockford作为业界知名专家，通过本书筛选了JavaScript中的优秀实践，避免了语言中复杂且容易引发问题的部分，使读者能更好地利用这一在Web开发中至关重要的脚本语言。这本书不仅仅是对JavaScript语法的深入解析，还包含了如何写出高性能代码的实用建议。它不同于传统的全面指南，而是精心挑选了那些在实际项目中能提高开发效率和代码质量的核心内容。《High Performance Web Sites》和《JavaScript and DHTML Cookbook》等其他资源，可以与《The Good Parts》形成互补，共同提升Web开发者的技能。 O'Reilly出版社是这本书的发行方，他们不仅提供了丰富的图书资源，还包括官方网站oreilly.com，这里不仅有完整的O'Reilly书籍目录，还有新闻、活动、文章、博客、样章和代码示例等，为开发者提供了全面的学习支持。对于关注开放和新兴技术的开发者来说，oreilly.net是一个不可或缺的平台，涵盖新的平台、编程语言和操作系统等领域的最新动态。此外，O'Reilly还举办各类技术会议，邀请行业创新者分享前沿技术和最佳实践，帮助开发者紧跟技术潮流。Safari Bookshelf作为在线参考图书馆，订阅用户可以迅速搜索并找到超过1000本书的答案，为解决技术问题提供实时支持。读者可以在Safari.oreilly.com上阅读《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页未读，继续阅读

EchoNM

粉丝: 0
资源: 2

精华版JavaScript:提升性能的实用指南

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

JavaScript语言精粹.修订版 Javascript：The Good Parts 中英 pdf

探索JavaScript：The Good Parts英文PDF版

JavaScript语言精粹(JavaScript.The.Good.Parts).pdf

精华版《JavaScript The Good Parts》电子书下载指南

JavaScript精华：The Good Parts - 全英文原著

JavaScript.The.Good.Parts.

JavaScript语言精粹 中文高清PDF版.7z

javascript语言精粹(中英文版)

JavaScript学习书籍PDF格式

最新资源

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

JavaScript语言精粹中文高清PDF版.7z