深入理解JavaScript：好部分解析

5星 · 超过95%的资源需积分: 10 88 浏览量更新于2024-07-28 收藏 5.78MB PDF 举报

"JavaScript_The_Good_Parts.pdf" 是一本关于JavaScript编程的书籍，由O'Reilly出版社出版。该书深入探讨了JavaScript语言的精华部分，帮助读者理解和掌握JavaScript的核心概念和技术。书中可能涵盖了高性能网页开发、JavaScript与DHTML的实战技巧、JavaScript的详尽指南，以及JavaScript学习的基础知识。在JavaScript的世界里，《JavaScript: The Good Parts》是不可或缺的读物。作者通过这本书向读者展示了如何利用JavaScript来创建高效、动态和交互性强的网页应用。书中的内容可能包括但不限于变量、数据类型、控制流、函数、对象、闭包、原型链等基础知识，以及异步编程、事件处理、DOM操作等高级话题。 O'Reilly出版社还提供了其他相关的技术资源，如《High Performance Web Sites》关注高性能网站的构建策略，《JavaScript and DHTML Cookbook™》提供了实用的代码示例和解决方案，《JavaScript: The Definitive Guide》作为JavaScript的权威指南，全面覆盖了语言的各个方面，而《Learning JavaScript》则适合初学者，提供了系统的学习路径。 O'Reilly的在线平台oreilly.com和oreillynet.com为开发者提供了丰富的资源，包括新闻、事件信息、文章、博客、样本章节和代码示例。此外，O'Reilly还会定期举办各种技术会议，聚集行业创新者，分享最新技术和趋势。访问conferences.oreilly.com可以获取最新的会议信息。 Safari Bookshelf（safari.oreilly.com）是一个在线参考图书馆，特别为程序员和IT专业人员设计。用户可以搜索超过1000本书的内容，迅速找到关键问题的答案，而且订阅者可以直接在线阅读书中的内容，方便快捷。《JavaScript_The_Good_Parts.pdf》是深入理解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页未读，继续阅读

bbbbbbbbbb

粉丝: 0
资源: 9

深入理解JavaScript：好部分解析

JavaScript.The.Good.Parts.

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

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

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

探索JavaScript：The Good Parts英文PDF版

Palm_webOS_Rough_Cuts.pdf

javascript.crockford.com.rar

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

JavaScript学习书籍PDF格式

2018promise最新详解.pdf

最新资源

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

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