JavaScript权威指南(第六版)

需积分: 10 87 浏览量更新于2024-07-24 收藏 11.05MB PDF 举报

"JavaScript_The_Definitive_Guide_6th" 《JavaScript_The_Definitive_Guide》第六版是David Flanagan撰写的一本权威性的JavaScript编程指南，它深入介绍了JavaScript语言的各个方面，旨在帮助读者全面理解并熟练掌握这种广泛使用的脚本语言。这本书涵盖了从基础语法到高级特性的全方位内容，对于JavaScript开发者来说是一份不可或缺的参考材料。在书中，作者David Flanagan详细讲解了JavaScript的核心概念，包括变量、数据类型、操作符、语句、函数、对象和类等基础知识。此外，他还深入探讨了DOM（文档对象模型）操作，使得读者能够动态地操纵网页内容。书中的章节还涉及了事件处理、错误处理、定时器、正则表达式、Ajax技术以及JavaScript的异步编程模型，这些都是现代Web开发中的关键元素。第六版更新了JavaScript的最新特性，如ES6（ECMAScript 2015）引入的箭头函数、模板字符串、类和模块系统等，这些新特性极大地提升了JavaScript的可读性和实用性。同时，本书也涵盖了浏览器兼容性问题，这对于跨平台的Web应用开发至关重要。除了语言本身，Flanagan还讨论了JavaScript的运行环境，如浏览器API，以及如何利用这些API来实现客户端的交互和通信。他还特别关注了安全性问题，教导读者如何编写安全的JavaScript代码，避免常见的安全漏洞。此外，书中包含了大量的示例代码，帮助读者理解和应用所学知识。每个章节后的练习题和挑战则鼓励读者动手实践，巩固学习效果。书末的索引为读者提供了快速查找特定主题的便利。《JavaScript_The_Definitive_Guide》第六版是JavaScript开发者和学习者的宝贵资源，它全面、深入地阐述了JavaScript语言，无论你是初学者还是经验丰富的开发者，都能从中受益匪浅。通过阅读此书，你将能够更好地驾驭JavaScript，创造出更具交互性和功能性的Web应用。

JavaScript: Names and Versions

JavaScript was created at Netscape in the early days of the Web, and technically, “Java-

Script” is a trademark licensed from Sun Microsystems (now Oracle) used to describe

Netscape’s (now Mozilla’s) implementation of the language. Netscape submitted the

language for standardization to ECMA—the European Computer Manufacturer’s As-

sociation—and because of trademark issues, the standardized version of the language

was stuck with the awkward name “ECMAScript.” For the same trademark reasons,

Microsoft’s version of the language is formally known as “JScript.” In practice, just

about everyone calls the language JavaScript. This book uses the name “ECMAScript”

only to refer to the language standard.

For the last decade, all web browsers have implemented version 3 of the ECMAScript

standard and there has really been no need to think about version numbers: the lan-

guage standard was stable and browser implementations of the language were, for the

most part, interoperable. Recently, an important new version of the language has been

defined as ECMAScript version 5 and, at the time of this writing, browsers are beginning

to implement it. This book covers all the new features of ECMAScript 5 as well as all

the long-standing features of ECMAScript 3. You’ll sometimes see these language ver-

sions abbreviated as ES3 and ES5, just as you’ll sometimes see the name JavaScript

abbreviated as JS.

When we’re speaking of the language itself, the only version numbers that are relevant

are ECMAScript versions 3 or 5. (Version 4 of ECMAScript was under development

for years, but proved to be too ambitious and was never released.) Sometimes, however,

you’ll also see a JavaScript version number, such as JavaScript 1.5 or JavaScript 1.8.

These are Mozilla’s version numbers: version 1.5 is basically ECMAScript 3, and later

versions include nonstandard language extensions (see Chapter 11). Finally, there are

also version numbers attached to particular JavaScript interpreters or “engines.” Goo-

gle calls its JavaScript interpreter V8, for example, and at the time of this writing the

current version of the V8 engine is 3.0.

To be useful, every language must have a platform or standard library or API of func-

tions for performing things like basic input and output. The core JavaScript language

defines a minimal API for working with text, arrays, dates, and regular expressions but

does not include any input or output functionality. Input and output (as well as more

sophisticated features, such as networking, storage, and graphics) are the responsibility

of the “host environment” within which JavaScript is embedded. Usually that host

environment is a web browser (though we’ll see two uses of JavaScript without a web

browser in Chapter 12). Part I of this book covers the language itself and its minimal

built-in API. Part II explains how JavaScript is used in web browsers and covers the

sprawling browser-based APIs loosely known as “client-side JavaScript.”

Part III is the reference section for the core API. You can read about the JavaScript array

manipulation API by looking up “Array” in this part of the book, for example.

Part IV is the reference section for client-side JavaScript. You might look up “Canvas”

2 | Chapter 1: Introduction to JavaScript

in this part of the book to read about the graphics API defined by the HTML5

<canvas> element, for example.

This book covers low-level fundamentals first, and then builds on those to more

advanced and higher-level abstractions. The chapters are intended to be read more or

less in order. But learning a new programming language is never a linear process, and

describing a language is not linear either: each language feature is related to other fea-

tures and this book is full of cross-references—sometimes backward and sometimes

forward to material you have not yet read. This chapter makes a quick first pass through

the core language and the client-side API, introducing key features that will make it

easier to understand the in-depth treatment in the chapters that follow.

Exploring JavaScript

When learning a new programming language, it’s important to try the examples in the

book, and then modify them and try them again to test your understanding of the

language. To do that, you need a JavaScript interpreter. Fortunately, every web browser

includes a JavaScript interpreter, and if you’re reading this book, you probably already

have more than one web browser installed on your computer.

We’ll see later on in this chapter that you can embed JavaScript code within <script>

tags in HTML files, and when the browser loads the file, it will execute the code. For-

tunately, however, you don’t have to do that every time you want to try out simple

snippets of JavaScript code. Spurred on by the powerful and innovative Firebug exten-

sion for Firefox (pictured in Figure 1-1 and available for download from http://getfirebug

.com/), today’s web browsers all include web developer tools that are indispensable for

debugging, experimenting, and learning. You can usually find these tools in the Tools

menu of the browser under names like “Developer Tools” or “Web Console.”

(Firefox 4 includes a built-in “Web Console,” but at the time of this writing, the Firebug

extension is better.) Often, you can call up a console with a keystroke like F12 or Ctrl-

Shift-J. These console tools often appear as panes at the top or bottom of the browser

window, but some allow you to open them as separate windows (as pictured in Fig-

ure 1-1), which is often quite convenient.

A typical “developer tools” pane or window includes multiple tabs that allow you to

inspect things like HTML document structure, CSS styles, network requests, and so

on. One of the tabs is a “JavaScript console” that allows you to type in lines of JavaScript

code and try them out. This is a particularly easy way to play around with JavaScript,

and I recommend that you use it as you read this book.

There is a simple console API that is portably implemented by modern browsers. You

can use the function console.log() to display text on the console. This is often sur-

prisingly helpful while debugging, and some of the examples in this book (even in the

core language section) use console.log() to perform simple output. A similar but more

intrusive way to display output or debugging messages is by passing a string of text to

the alert() function, which displays it in a modal dialog box.

Introduction to JavaScript | 3

x = null; // Null is a special value that means "no value".

x = undefined; // Undefined is like null.

Two other very important types that JavaScript programs can manipulate are objects

and arrays. These are the subject of Chapter 6, Objects, and Chapter 7, Arrays, but they

are so important that you’ll see them many times before you reach those chapters.

// JavaScript's most important data type is the object.

// An object is a collection of name/value pairs, or a string to value map.

var book = { // Objects are enclosed in curly braces.

topic: "JavaScript", // The property "topic" has value "JavaScript".

fat: true // The property "fat" has value true.

}; // The curly brace marks the end of the object.

// Access the properties of an object with . or []:

book.topic // => "JavaScript"

book["fat"] // => true: another way to access property values.

book.author = "Flanagan"; // Create new properties by assignment.

book.contents = {}; // {} is an empty object with no properties.

// JavaScript also supports arrays (numerically indexed lists) of values:

var primes = [2, 3, 5, 7]; // An array of 4 values, delimited with [ and ].

primes[0] // => 2: the first element (index 0) of the array.

primes.length // => 4: how many elements in the array.

primes[primes.length-1] // => 7: the last element of the array.

primes[4] = 9; // Add a new element by assignment.

primes[4] = 11; // Or alter an existing element by assignment.

var empty = []; // [] is an empty array with no elements.

empty.length // => 0

// Arrays and objects can hold other arrays and objects:

var points = [ // An array with 2 elements.

{x:0, y:0}, // Each element is an object.

{x:1, y:1}

];

var data = { // An object with 2 properties

trial1: [[1,2], [3,4]], // The value of each property is an array.

trial2: [[2,3], [4,5]] // The elements of the arrays are arrays.

};

The syntax illustrated above for listing array elements within square braces or mapping

object property names to property values inside curly braces is known as an initializer

expression, and it is just one of the topics of Chapter 4, Expressions and Operators. An

expression is a phrase of JavaScript that can be evaluated to produce a value. The use

of . and [] to refer to the value of an object property or array element is an expression,

for example. You may have noticed in the code above that when an expression stands

alone on a line, the comment that follows it begins with an arrow (=>) and the value of

the expression. This is a convention that you’ll see throughout this book.

One of the most common ways to form expressions in JavaScript is to use operators

like these:

// Operators act on values (the operands) to produce a new value.

// Arithmetic operators are the most common:

3 + 2 // => 5: addition

1.1 Core JavaScript | 5

3 - 2 // => 1: subtraction

3 * 2 // => 6: multiplication

3 / 2 // => 1.5: division

points[1].x - points[0].x // => 1: more complicated operands work, too

"3" + "2" // => "32": + adds numbers, concatenates strings

// JavaScript defines some shorthand arithmetic operators

var count = 0; // Define a variable

count++; // Increment the variable

count--; // Decrement the variable

count += 2; // Add 2: same as count = count + 2;

count *= 3; // Multiply by 3: same as count = count * 3;

count // => 6: variable names are expressions, too.

// Equality and relational operators test whether two values are equal,

// unequal, less than, greater than, and so on. They evaluate to true or false.

var x = 2, y = 3; // These = signs are assignment, not equality tests

x == y // => false: equality

x != y // => true: inequality

x < y // => true: less-than

x <= y // => true: less-than or equal

x > y // => false: greater-than

x >= y // => false: greater-than or equal

"two" == "three" // => false: the two strings are different

"two" > "three" // => true: "tw" is alphabetically greater than "th"

false == (x > y) // => true: false is equal to false

// Logical operators combine or invert boolean values

(x == 2) && (y == 3) // => true: both comparisons are true. && is AND

(x > 3) || (y < 3) // => false: neither comparison is true. || is OR

!(x == y) // => true: ! inverts a boolean value

If the phrases of JavaScript are expressions, then the full sentences are statements, which

are the topic of Chapter 5, Statements. In the code above, the lines that end with

semicolons are statements. (In the code below, you’ll see multiline statements that do

not end with semicolons.) There is actually a lot of overlap between statements and

expressions. Roughly, an expression is something that computes a value but doesn’t

do anything: it doesn’t alter the program state in any way. Statements, on the other

hand, don’t have a value (or don’t have a value that we care about), but they do alter

the state. You’ve seen variable declarations and assignment statements above. The

other broad category of statement is control structures, such as conditionals and loops.

Examples are below, after we cover functions.

A function is a named and parametrized block of JavaScript code that you define once,

and can then invoke over and over again. Functions aren’t covered formally until

Chapter 8, Functions, but like objects and arrays, you’ll see them many times before

you get to that chapter. Here are some simple examples:

// Functions are parameterized blocks of JavaScript code that we can invoke.

function plus1(x) { // Define a function named "plus1" with parameter "x"

return x+1; // Return a value one larger than the value passed in

} // Functions are enclosed in curly braces

6 | Chapter 1: Introduction to JavaScript

剩余1076页未读，继续阅读

anchao1987

粉丝: 0

JavaScript权威指南(第六版)

ActionScript.权威指南.AS.The.Definitive.Guide

VS2015安装证书，JavaScript_ProjectSystem.msi，JavaScript_LanguageService.msi

html_css_avascript

avaScript文档对象模型

avaScript表单验证大全

avaScript语法概述.pdf

avascript参考手册CHM版

众多avaScript特效代码合集

avaScript 延时

avaScript 正则表达式

最新资源