JavaScript精华：剔除冗余，打造高效编程

需积分: 10 5 浏览量更新于2024-07-23 收藏 2.09MB PDF 举报

《JavaScript: The Good Parts》是由Douglas Crockford撰写的一本权威书籍，于2008年5月2日由O'Reilly出版社出版，ISBN-13为978-0-596-51774-8，共170页。该书针对JavaScript语言进行了深度剖析，因为JavaScript在早期开发阶段未能充分优化，导致存在较多问题。Crockford作为业界公认的JavaScript专家，旨在揭示一种更可靠、可读性强且易于维护的JavaScript子集，这对于新手和高级开发者来说是一本极具价值的进阶读物。书中主要内容包括以下几个方面： 1. **语法**（Syntax）：Crockford首先介绍JavaScript的基础语法，帮助读者理解和掌握其构造，以便更好地编写代码。 2. **对象**（Objects）：JavaScript的对象模型是其核心概念之一，Crockford解释了如何利用对象进行数据封装和组织，以及它们在函数式编程中的作用。 3. **函数**（Functions）：书中强调了JavaScript强大的函数功能，如闭包、柯里化等，这些都是实现模块化和代码复用的关键。 4. **继承**（Inheritance）：虽然JavaScript的继承机制曾被批评为复杂和问题重重，但Crockford讲解了如何通过构造函数和原型链创建更为清晰的继承关系。 5. **数组**（Arrays）：JavaScript的数组处理方式及其内置方法，如map、reduce和filter，对高效处理数据至关重要。 6. **正则表达式**（Regular expressions）：JavaScript强大的文本处理能力，通过正则表达式，可以轻松执行复杂的字符串操作。 7. **方法**（Methods）：书中详细讨论了JavaScript对象的方法，以及如何设计和使用这些方法来增强代码的灵活性和可维护性。 8. **风格**（Style）：Crockford提倡的编程风格，强调简洁、清晰和一致的代码，这对于提高代码质量有着深远影响。 9. **美丽特性**（Beautiful features）：尽管存在问题，但书中也展示了JavaScript的一些优秀特性，比如事件驱动编程和异步编程模型，这些都是其独特魅力所在。 10. **缺陷与改进**（Bad and Awful ideas）：Crockford指出了全局变量导致的问题，以及编程模式上的局限，以此为鉴，引导读者避免这些问题，选择更健康的编程实践。《JavaScript: The Good Parts》是一部帮助开发者理解和精炼JavaScript语言精华，去除冗余和不良习惯的实用指南，适合想要深入学习和提升JavaScript技能的专业人士。通过阅读这本书，开发者能够构建出更加健壮、高效和可维护的JavaScript代码。

1.1. 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 languages 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 painful 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 surprised 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 programming. 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.

Chapter 1. Good Parts

...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 language 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 popularity is almost

completely independent of its qualities as a programming language.

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 outstanding,

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.

1.2. 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 expressive 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 theory 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 languages. 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 checking 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 popular 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 mitigate 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.

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 provides 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

剩余369页未读，继续阅读

ynjuan99

粉丝: 0

JavaScript精华：剔除冗余，打造高效编程

深入理解JavaScript系列

head first JavaScript源码

JavaScript权威指南（JavaScript犀牛书一本）

javascript

JavaScript JavaScript JavaScript

Javascript-javascript

JavaScript基础JavaScript Essentials

javascript教案 JavaScript基础

【JavaScript】vue动态加载JavaScript 高级JavaScript组件

非JavaScript编写JavaScript工具的精选列表-JavaScript开发

最新资源