Errata

The text


*To make use of a Keymap, call its install() method, passing an HTML element,
* such as the document object. install() adds an onkeydown event handler to
* the specified object.

change to

*To make use of a Keymap, call its install() method, passing an HTML element,
* such as the document object. Install() adds an onkeydown event handler to
* the specified object.

The dot behind object should be a stop rather than expression.3Q((。(^_^)。))

This is regarding the following code example:

for(var i = 0; i < a.length; i++ {
if(!a[i]) continue; // Skip null, undefined and nonexistent elements
}

I think it's fair to say the code sample is somewhat misleading, because it will not work as intended if an array element contains a boolean value of false. The comment in the example says "Skip null, undefined, and nonexistent elements." That statement is correct, but it doesn't mention that if a[i] evaluates to false it will also be skipped via the continue statement.

in function getcookie, the variable of cookie is used in wrong way, my print is chinese edition.

> The throw statement is a kind of interim return from a generator function.

I'd guess that is likely supposed to be "yield" and not "return".

Meta-errata:

> The throw statement is a kind of interim return from a generator function.

s/throw/yield/ (my previous submission had the wrong target)

The example code fails on Chrome 28 when loaded info a browser with the file:// scheme. The access to localStorage in line 117 fails with a SecurityError: DOM Exception 18. The script works fine if you have a local webserver and can serve the page via http://

The section 2.4.1 on reserved words is misleading as far as the reserved words class, const, enum, export, extends, import and super are concerned.

The second paragraph in this section says these were reserved in ECMAScript 5. In the last paragraph it says the reserved words policy has been relaxed in ECMAScript 5 and lists the above again as part of a big list of Java language keywords. Since they were said to be reserved in ECMAScript 5, they should be excluded from here.

The text clearly shows that the greek letter 'pi' is the first
and only letter in the identifier.

This contradicts the text in the preceding paragraph.

The greek letter 'pi' may be the second or later letter of
an identifier, but not the first.

6th edition, 3.3 boolean values, the sentence "All other values, including all objects..."

My comment may seem very pedantic, but I will post it here anyway.

You said this:
--begin of quote--
The following values convert to, and therefore work like, false:

undefined
null
0
-0
NaN
"" // the empty string

All other values, including all objects (and arrays) convert to, and work like, true
--end of quote--

You didn't mention "false" in the list, so, formally, "false" is in "all other values" and so false convert to true. So, literal meaning of this sentence implies false convert to true. Yes, probably, nobody will interpret it such way, but I think this is still good idea to fix somehow the sentence. Add "false" to the list or say "All other values (excluding "false")".

In the second sentence of the second paragraph on page 41 it is stated:

"The second case is less strict: ..."

Actually it is the opposite. The first case:

if (o !== null) ...

is less strict than the second case:

if (o) ...

The first case will execute the body of the if-statement only if any value other than null has been assigned to o. That is, it will execute the body of the if-statement even for undefined, 0, -0, NaN and "". Whereas the second case will execute the body of the if-statement only if o has been assigned a truthy value, that is, any value just not null, undefined, 0, -0, NaN and "".

CURRENT STATE:
If two distinct string values are compared, JavaScript treats them as equal if,
and only if, they have the same length and if the character at each index is the same.

SUGGESTION:
If two distinct string values are compared, JavaScript treats them as equal if,
and only if, they have the same length and if the 16-bit value at each index is the same.

The table implies that any array except for [] and single-numeric-element array such as [9] converts to non-NaN number. But this is not true. ["2"] converts to 2.

"+, ==, != and the relational operators are the only ones that perform this special kind of
string-to-primitive conversions."

Are you sure you meant string-to-primitive here? Maybe object-to-primitive?

Written:
console.log(j); // j is defined, but may not be initialized

j may be not defined if typeof o != "object"

The details of this object-to-number conversion explain why an empty array converts to the number 0

// I tested in chrome, empty array converts to empty string, not 0

Author writes:
"A newline is not allowed between the break keyword and the label name."

This to me is quite misleading as it implies that doing so will result in some sort of error., which is not the case.

Maybe the above sentence should be rephrased to say:

A newline between the break keyword and the label name will cause the label to be ignored.

/*
* Return a new object that holds the properties of both o and p.
* If o and p have properties by the same name, the values from o are used. */
function union(o,p) { return extend(extend({},o), p); }

The second sentence of the comment says that where properties use the same name, the values from o are used. I believe this should be in reverse - properties using the same name use the values from p, not o.

For example:

var stock = {name: "AT&T", shares: 100};
var quote = {name: "ATT", shares: 50, price: 32.5};
extend(stock,quote);

returns:
({name:"ATT", shares:50, price:32.5})

Notice that the properties from quote overwrite the properties in stock with the same name.

Printing error
not Object.isExtensible( ) but Object.isExtensible( )

When testing ....

var undefs = [ , , ] ;

The length of the array was 3 .

The original:
“What is special about arrays is that when you use property names that are non-negative integers less than 2^32, the array automatically maintains the value of the length property for you.”
Should be modified as:
Less than 2^32 – 1

It reads as follows:
"Arrays that are sufficiently sparse are typically implemented in a slower, more memory-efficient way than dense arrays are, and looking up elements in such an array will take about as much time as regular object property lookup."
How is it both "slow" and "memory-efficient"? I think it should be memory-intensive.

The original:
“What is special about arrays is that when you use property names that are non-negative integers less than 2^32, the array automatically maintains the value of the length property for you.”
Should be modified as:
Less than 2^32 – 1

In the last paragraph of section 6.10.6, the snippet comment reads :

"The expression "random.octet", for example, yields a random number between 0 and 255 each time it is evaluated."

However, the range is 0-256 if Math.random() evaluates to 1: Math.floor(Math.random()*256);

Here's the full snippet of the book:
// This object has accessor properties that return random numbers.
// The expression "random.octet", for example, yields a random number
// between 0 and 255 each time it is evaluated.
const random = {
get octet() { return Math.floor(Math.random()*256); },
get uint16() { return Math.floor(Math.random()*65536); },
get int16() { return Math.floor(Math.random()*65536)-32768; }
};

This concerns the inherit function in Javascript - The Definitive
Guide 6th edition:

var obj = { p1: 0, p2: new Array(10)}

var tab = [inherit(obj), inherit(obj)];

tab[0].p1 = 1;
tab[0].p2[0] = 'F';

tab[1].p1 = 2;
tab[1].p2[0] = 'S';

Note that for for both entries in tab, p2[0] is set to 'S'!

The book states "A function declaration statement actually declares a variable and assigns a function object to it. A function definition expression, on the other hand, does not declare a variable."

I believe these are reversed. A function declaration does not declare a variable, while a function definition expression does.

The following is an example of a function definition expression where the function object IS assigned to a variable:

var tensquared = function(x) { return x*x; };


And the following is an example of a function declaration statement where the function object is assigned to an identifier, not to a variable:

function distance( x1, x2 ) { return x2 - x1; };

The book says: "Every function has a prototype property that refers to an object known as the prototype object." The standard requires this of (most) functions defined by the user, but it does not appear to be true of most built-in functions.

According to Chrome (23.0.1271.101) and Safari (5.1.7) none of the following function objects have a 'prototype' property: the function prototype (i.e., Function.prototype), Object.create, String.prototype.charAt, Date.prototype.getMilliseconds, Date.now

In fact, it may be the case that no built-in function other than the obvious constructors (Object(), Date(), Array(), ...) has a prototype associated with it.

Section 13.2 of ECMA-262 discusses the process of creating functions. In particular, steps 16 and 18 refer to the creation of a corresponding prototype object and its association with the new function through its 'prototype' property. The section ends with the following note: "A prototype property is automatically created for every function, to allow for the possibility that the function will be used as a constructor." This note may shed some light on why built-in functions don't have 'prototype' properties since they will never be used as constructors. It is more efficient to avoid creating the unnecessary prototype objects in this case.

Furthermore, section 15.3.5.2 discusses the special case of functions creted by means of bind(): "Function objects created using Function.prototype.bind do not have a prototype property." So it's not even true that all user-defined functions have a 'prototype' property.

"JavaScript is not a functional programming language like Lisp or Haskell". I disagree. Moreover, JavaScript is inspired by Scheme (Lisp dialect). Original JS is essentially Scheme with Java syntax

I believe that this line... if (i in a) results[i] = f.call(o || null, a[i], i, a);

should either be this: if (i in a) results[i] = f.call(o || null, a[i]);

or this: if (i in a) results[i] = f.apply(o || null, [a[i], i, a]);

From the Confirmed Erata page:

Description:
The "if (i == len)" statement causes reduce to throw a TypeError when it is called with an array containing a single element and no initial value.

Note from the Author or Editor:
Change if (i == len) to if (i == len && len > 1)

Comment/Question:
Even with the above change, an error is still thrown for sparse arrays, for example [ , , 1].

Is the line (i == len && len >1) even needed? When that line is commented out, the code appears to work for all cases.

The paragraph provides a way to easily test for an existing array, and to assign it to a variable, or, if no array exists, create a new one: a = a || [];
The problem is the explanation uses the word "object" instead of "array":

"In this case, if any object is passed as the second argument, the function will use that object"

The book reads:
If we define a constructor using an unnamed function definition expression, the getName() method will return an empty string.

That's just not true. In Chrome I wrote this:
var c = function(x){this.x=x}
var o = new c(1);

Querying o.constructor.name, the result is: "c".
Defining and using the getName() function of yours, the result is still the same, o.constructor.getName() returns "c".

The NonNullSet 's' created by means of FilteredSet is not identical to the earlier definition since the filter tests x !== null. This only weeds out null values and not undefined values. The earlier implementation effectively filters using the less strict x != null, which applies to undefined values as well.

to Author:
calling the function toString() of such an object below leads to an error:
var testa = {
A:1,
get a(){return this.A},
set a(x){this.A = x}
};
the output of the code " testa.properties().toString() " is:
"{
A: 1,
readonly accessor a
}"
But obviously, "a" is not readonly. Thats's because the 'writable' property of 'a' is ''undefined' which gets a Boolean false. And the code "!desc.writable" of 13th line from bottom makes output of function totSring() have an extra "readonly".
Both Chrome 39 and Firefox 43 tested.

The erroneous term 'CSS class' crops up in the book in several places.

It's not a 'CSS class', it's an HTML element 'class' attribute. 'HTML class' would perhaps be a better shorthand way to refer to it.

Given that the book is so excellent in its terminological accuracy throughout, this term should be replaced with something better.

A quick search through the PDF version of the book finds many other occurrences, of which the following are a sample:

page 309: 2nd paragraph 'CSS classes'
page 364: section 15.2, 4th bullet point 'CSS class'
page 437: section 16.5 heading contains 'CSS Classes'
page 525: 1st paragraph 'CSS Class
page 532: section 19.2.3 heading contains 'CSS Classes'

The term also appears in comments in sample code.

Example 13-1 is somewhat misleading. The loop through each element whose class is "reveal" suggests that clicking on the first "handle" child of each such element will reveal the element containing the handle. However, since each onclick handler shares the same elt variable, the only elements that will be revealed are those in the final element with class "reveal".

Since the example contains only a single element whose class attribute is "reveal", the behavior is fairly intuitive. Adding a second or third "reveal" element might cause some surprises.

<html>
<head>
<title>Sample Document</title>
</head>
<body>
<h1>An HTML Document</h1>
<p>This is a <i>simple</i> document.
</html>

As has already been noted the closing </body> tag is missing from the code example above.

Also missing is the closing </p> tag, which should appear as so:

<p>This is a <i>simple</i> document.</p>

Function getViewportSize treats window.innerWidth/Height and document.documentElement/body.clientWidth/Height as equivalent but in fact they are different: innerWidth/Height includes space covered by scrollbars while clientWidth/Height does not.

I confirmed this on my system, and you can also find it here:
http://www.quirksmode.org/mobile/viewports.html
(search for heading "Two property pairs")

classes.search( "\\b" + c +"\\b" ) != -1 is not a reliable solution, e.g.:
"x-list-header-inner".search("\\bx-list-header\\b") == 0 while
"x-list-header-inner" != "x-list-header"

The ActiveXObject "Msxml2.XMLHTTP.3.0" could usefully be replaced by "Microsoft.XMLHTTP". As the former always points to the latter, nothing would be lost by this and even older versions of the IE browser would be supported.

If this change was made then the title of the box would need to be updated to "XMLHttprequest in IE5 and IE6".

The example does not upload a file via POST. XHR doesn't append the file to the request body.

Browsers Tested (on Ubuntu 12.10):
Google Chrome 26.0.1410.63
Mozilla Firefox 20.0

Not so much a mistake as an alternative.

"Second, Firefox 4 no longer fires a popstate event for newly loaded pages that do not have any saved state. This second change means that the example below does not work quite right in Firefox 4."

Firefox 4 does fire the pageshow event, so it works right if you bind popState to that. I added this on line 6 of the listing:

window.onpageshow = popState;

The author asserts that - quote:

Math.max()
Returns the larger of two numbers.
Math.min()
Returns the smaller of two numbers

The above is quite misleading, as it implies that these functions will only inspect the first 2 arguments - which is of course incorrect.

Instead, see the definition on MDN:
"The Math.min() function returns the smallest of zero or more numbers." and
The Math.max() function returns the largest of zero or more numbers.

An assertion is made that String.substr() is deprecated.

I believe that this is a mistake because I could not find any written evidence in the spec or elsewhere that is it deprecated.

Second sentence reads, "This property mirrors the value attribute."
This entire paragraph is *about* the value attribute, so how can it mirror itself? Was there supposed to be something else that it mirrored, or was it supposed to be mirrored by something else? Position possibly? It makes determination of which attribute to remove to change determinate/indeterminate confusing.

there is no mention of the cast to boolean operator !!

I noticed this when attempting to use this book to determine what the !! operator was in reading the source code for the com.google.gwt.dom.client.Node class