Errata

javascript:x = 3; (x > 5)? "x is less": "x is greater"
should be:
javascript:x = 3; (x > 5)? "x is greater" : "x is less"

The code

false == (x > y)
(x == 2) && (y == 3)
(x > 3) || (y < 3)

will result in TypeErrors.
`(x == 2)` and `(y ==3)` will be evaluated as functions without semicolons (if executed from a file).

See:
https://stackoverflow.com/questions/34214629/strange-typeerror-in-node-js/34214753

I don't know if it's a mistake. The code examples may not have the intention of being executed in a file. I just thought I'd send something in, see if it actually was a mistake or not

when looking for the JavaScript console under the Tools menu in Firefox, its labeled as Error Console. I was a little confused by that.

Incorrect details in description of Unicode:

1. Unicode is a character set but it is not generally used as an encoding. UTF-8 (and UTF-16) are commonly used encodings that can represent any Unicode character. The use of the Unicode number for a character in JavaScript literals such as "\u03c0" is an escape sequence, not an encoding.

2. Unicode has grown over time. It's no longer 16 bits, although that's plenty good for most purposes. Code points now go up to 0x10FFFF, which requires 21 bits. FWIW, Java supports all these characters as of (I think) the 5.0 JDK, which means a single Unicode character may be represented in 2 16 bit Java chars.

See:
http://en.wikipedia.org/wiki/Character_encoding
http://en.wikipedia.org/wiki/Unicode

I think I found a little bug in one of the examples in the book:

example 15-9. A logging facility for client-side JavaScript.

It should not work for IE because it needs a tbody element in a table element.
You can find the elements in the dom tree by IE Developer toolbar but you
cannot see anything of a table in the page.

Thank you for this GREAT book!!!

Unicode is not a 16-bit encoding.

In Java 1.5 with autoboxing the following code is legal,
Object o = null;
o = 10;
o = "hey";
Autoboxing is overlooked in section 4.1, Variable Typing

var o = {x:1,y:{z:3}};
var a = [o,4,[5,6]];

here is mistake
a[0].x // => 1: property x of expression a[0]

[
For example, the following code sets both i and j to 2:
i = 1;
j = ++i;
But these lines set i to 2 and j to 1:
i = 1;
j = i++;
]

No, the first two lines set i to 1 and j to 2.

The second two lines set both i and j to 1.

The last line in this paragraph says:

...this line enumerates the array "properties", 0, 1, and 2: ...

It should be:

...this line enumerates the array "properties", "0", "1", and "2":

(I am saying this because I think the names of the object/array properties are always strings).

line: var undefs = [,,]; ....
comment should say "An array with 3 elements, all undefined"

var undefs = [,,]; // An array with two elements, both undefined

This has been previously reported (by me?!), but not quite correctly.

The number of elements created appears to be browser-dependent.
IE7 for Windows creates three elements, apparently inferring an element following the trailing comma. FF2 for Windows creates 2...probably because it seems to ignore a final trailing comma in a list (similar behaviour to Perl).

"If this second argument is omitted, all array elements from the start element to the end of the array are removed."

probably should read:

"If this second argument is omitted, inconsistent behavior across browser implementations will occur. Use 0 to specify no deletions and the length method to delete all array elements from start element to end of array."

In the example following the paragraph:

a.splice(4);

should be:

a.splice(4,a.length); // works with Firefox & IE, but maybe not safe?

or

a.splice(4,(a.length-4);

Anyway, paragraph needs to be corrected.

In the function copyUndefinedProperties(), "if (!p in to)" is used to check whether
the object "to" lacks property "p". Since the unary ! operator has a higher
precendence than the "in" operator (see Table 5-1, pp. 60-61), this statement is
incorrect: p is first negated to obtain !p, and then it is checked whether !p is a
property of to. Parentheses are needed: "if (!(p in to))".

Because the ! operator has higher precedence than the in operator, the function just checks to see if
"false" is in the to object for each property in the from object. Function should be:

function cu(from, to) {
for(p in from) {
if (!(p in to)) to[p] = from[p]; // parentheses around 'p in to'
}
}

Section 7.3 example

var a1 = [,,,]; // This array is [undefined, undefined, undefined]
var a2 = new Array(3); // This array has no values at all
0 in a1 // => true: a1 has an element with index 0
0 in a2 // => false: a2 has no element with index 0

0 in a1 actually evaluates to false. It is not true. Tested in Mozilla Scratchpad.

"When you use JavaScript objects to *simulate* object-oriented programming techniques ..." [emphasis
added]

maybe should be something like:

"When you use JavaScript objects to simulate the object-oriented programming techniques of strictly-typed
languages ... "

On page 157: "JavaScript is a true object-oriented language."

If that's true, we shouldn't need to simulate object-oriented programming techniques. If we do need to
simulate them, then JavaScript must not be a true object-oriented language.

Remove the 'new' keyword.

The book recommends using "args.to_start || 0" in order to process an optional parameter. This produces an error in Firefox and seems to be bad practice. If the parameter was passed but evaluates to false it won't be used. See explanation of what I mean here:
http://stackoverflow.com/questions/148901/is-there-a-better-way-to-do-optional-function-parameters-in-javascript

The hyphen "-" is wrongly omitted from the list of punctuation characters that have special meanings in regular expressions.

The characters '=', '!', and ':' do not have special meaning in a regex.

It looks like there's an extra closing parentheses in "/(ab|cd)+|ef)/"

Book: "If Microsoft were to define an addEventHandler() method ..."
Should read: "If Microsoft were to define an addEventListener() method ..."

your definition of 'viewport' is (as it should be) the window minus menus, scrollbars, etc.

your code works as advertised in the browsers OmniWeb and Safari on MacOS X Leopard.

with the browsers Camino, Firefox, Mozilla, Navigator, SeaMonkey (all on MacOS X) and Internet Explorer 7
(on Win XP) your code returns the width of a frame including the scrollbar.

Specifically on Safari, the proper width is the 'computed style width' of the body; however, this value
appears to be 'auto' in the other browsers.

Example 15-9

table.appendChild(row);

is not a good idea for Internet Explorer -- wants rows appended to tbody (or thead or tfoot)
Firefox and Safari happy as clams
I notice the screen shot (Figure 15-4) is for Firefox

I admit I didn't use this script, but I can tell you that I had no luck directly appending rows to a
table in MSIE. (Nothing displayed.) Cured by appending to tbody and then appending tbody to table. Found
the cure by Googling.

The book references the [cookieEnabled] property as if it were a method, ie: cookiesEnabled(). In addition, it references the property as if it were plural (cookies) rather than singular (cookie). The proper reference would be:

navigator.cookieEnabled, not: navigator.cookiesEnabled()

In example 16-4 (tooltip.js), the comments in the CSS are not formatted correctly. This is probably because they cannot be nested in JavaScript, but confusing to the reader who tries to uncomment the example CSS class definitions and use them.

There should be a note that all the "* /" must be changed to "*/ to work correctly.

Same applies to the downloadable examples.

In the second sentence of the last paragraph "The HTML DOM Level 2 standard defines a disabled property for both <link> and <script> elements." the tag <script> should be the tag <style>.

In the second sentence of the last paragraph "The HTML DOM Level 2 standard defines a disabled property for both <link> and <script> elements." the tag <script> should be the tag <style>.

This code block is missing a comma at the end of the third line. It should read:

function(event) { listener.handleEvent(event); },

Nothing but praise for this excellent book. I found a nasty little error in the book:

for instance, when adding an onclick event to a <a> tag, using Handler.Add(aLink,"click",myhandler) does not return false or true when the link is clicked, so it is not possible to stop the link performing the default action.
when the line
handler.call(element,event);
is changed into
return handler.call(element,event);
it works as expected.

kind regards,

The comments in the example code on p417 imply that an element always has a "document" property, then the code on 418 goes on to make that assumption.

But nowhere (that I can find) in the text of the book is this documented.

It seems that an undocumented feature of IE is being employed, since there is no "document" property attached to an element in FF according to my test.

I realise the example is specifically targeted at the IE browser, but it would be much more helpful if attention was drawn to the undocumented nature of this usage (if that is indeed the case).

Note that the "document" property of an element is not mentioned in the Reference section either, causing further confusion, since in general the Reference section identifies browser-specific implementations.

The comment is wrong, according to the code. Instead of
// Firefox gives us printing keys in e.charCode, IE in e.charCode
It should be:
// Firefox gives us printing keys in e.charCode, IE in e.keyCode

As reported by a previous person the Cookie function has a problem on Firefox because of a space that is
added after the semicolon to split the cookies. Thus this line:

var cookies = allcookies.split(';');

Leaves a space after the split and thus doesn't work correctly when looking up cookie names. The previous
errata reporter said this could be fixed like so:

var cookies = allcookies.replace(' ', '').split(';');

This is not correct either because the replace needs to be global, not just for the first match:

var cookies = allcookies.replace(/ /g, '').split(';');

The anonymous functions that are defined should end with a semicolon.

Currently the books shows them as
Cookie.prototype.store = function(daysToLive, path, domain, secure) {
...
}

when they should be
Cookie.prototype.store = function(daysToLive, path, domain, secure) {
...
};

There are three such errors across pages 464 and 465. The first is halfway down page 464, the second is
just above the comment block at the bottom of page 464, and the third is at the end of the first code
section on page 465.

At the end of the code example (20-1) there is no closing semicolon. This has been
copied into the http.js file supplied as part of this chapter. All other functions
in this file have closing semicolons.

The example says:

var pattern = /java/i;
pattern.test("JavaScript"); // Returns true
pattern.test("ECMAScript"); // Returns false

But the second test returns false not because it doesn't contain the pattern, but
because of the side effect on the lastIndex in the pattern regular expression.

There should be a mention of this side effect on lastIndex in the Description section
for test, and reference exec and lastIndex for more complete description.

This *dangerous* side effect should be mentioned also in String.match, .search,
.replace, and any other place that applies.

In that class in constructor we specify the expression to
evaluate and than call call the "getNodes" or "getNode" function. In the
instance of the class we store a link to XPathExpression object that we
created by "document.createExpression()" function. In "getNodes" or
"getNode" function we specify a context from which we want to evaluate the
expression. The problem is that if this context is different from "document"
object from which we call "createExpression()" function, we have an
exception with a message "Node cannot be used in a document other than the
one in which it was created". One of solutions to this problem is to store a
link to context in our "XPathExpression" class and in functions "getNodes"
and "getNode" call "evaluate()" function on him.

The ImageLoop constructor function sets the image load event for each image before the event function is
ready. The result is that the event handler can fail if the images have been cached.
What really matters is the "var loop = this;" line. If the browser loads the image in a separate thread
the event handler can fire and call countLoadedFrames() before that line is executed.
I see this most often with IE7. The fix is to move the event handler code before the loop that processes
the image URLs:

// This nested function is an event handler that counts how many
// frames have finished loading. When all are loaded, it sets a flag,
// and starts the animation if it has been requested to do so.
var loop = this;
function countLoadedFrames( ) {
loop.loadedFrames++;
if (loop.loadedFrames == loop.frames.length) {
loop.loaded = true;
if (loop.startOnLoad)
loop.start( );
}
}

// Initialize the frames[] array and preload the images
for(var i = 0; i < frameURLs.length; i++) {
this.frames[i] = new Image( ); // Create Image object
// Register an event handler so we know when the frame is loaded
this.frames[i].onload = countLoadedFrames; // defined above
this.frames[i].src = frameURLs[i]; // Preload the frame's image
}

Agree to the other comment on this issue. I had the same problem in Firefox 3.6.

The callback function must havbe been defined in code before possibly called. Apparently parsing a JavaScript file is not a 2-pass process but a 1-pass process.

Since,

"a.splice(4); // Returns [5,6,7,8]; a is [1,2,3,4]"

was removed from text of the printed copy I recently purchased, the results in the following operations are incorrect.

var a = [1,2,3,4,5,6,7,8]
a.splice(1,2); // Returns [2,3]; a is [1,4]
a.splice(1,1); // Returns [4]; a is [1]
a.splice(1,0,2,3); // Returns []; a is [1 2 3]

should be:
var a = [1,2,3,4,5,6,7,8]; // was missing semicolon
a.splice(1,2); // Returns [2,3]; a is [1,4,5,6,7,8]
a.splice(1,1); // Returns [4]; a is [1,5,6,7,8]
a.splice(1,0,2,3); // Returns []; a is [1,2,3,5,6,7,8]

The book says that Math.random() returns "A pseudorandom number between 0.0 and 1.0." Section 15.8.2.14
of ECMA-262 says it "Returns a number value with positive sign, greater than or equal to 0 but less than
1". That "less than 1" can be of significance, since Math.floor(Math.random() * N) where N is an integer
might return N itself; otherwise, we can safely assume that expression will return an integer from 0 to
N-1.

The Bugs section for String.substr() states in part,
"Negative values for start do not work in IE 4 (this is fixed in later versions of IE)."
However, I do not think that this problem has ever been fixed in IE. I just tried it in IE 7 and it's
still broken.

The sample output seems to have been based on a different original source array, so the actual output values differ from what the book indicates. When I try the second example with Node.js, I get the following:

$ node
> var a = [1,2,3,4,5,6,7,8]
undefined
> a
[ 1,
2,
3,
4,
5,
6,
7,
8 ]
> a.splice(1,2);
[ 2, 3 ]
> a
[ 1,
4,
5,
6,
7,
8 ]

The Inherits from section should presumably end with Image rather than Input

But is the inheritance chain correct otherwise??

The Image object is described as having onload, onerror, and onabort event handler attributes. Those
attributes are not valid (X)HTML for the IMG tag, and the DOM does not indicate that the HTMLImageElement
has those properties (e.g. the load event only applies to the body, FRAMESET, and OBJECT elements--see
DOM2-Events section 1.6.5).

However, it appears most browsers support these attributes.

Book: "name=value1,value2,...,valuen"
Should read: "name=value1&name=value2&...&name=valuen"

Book: "the onclick handler is also triggered when the user activates the element using keyboard traversal."

Should read: "... using a dedicated trigger key on the keyboard. Most modern browsers are using the [SPACE] key to trigger the onclick event."


...otherwise the event's name was "onfocus" ;)

Book: "The most deeply nested Document node"
Should read: "The most deeply nested Element node"

In the Throws section, it should say
"if index is less than -1", rather than "if index is less than 0".

The text says that Table.insertRow(index) throws a DOMException if index is negative, but the DOM2 HTML spec says that a value of -1 for index causes the new row to be appended to the table. (Firefox and Opera both treat -1 that way; I haven't tested other browsers.)

The same applies to TableRow.insertCell() on page 904.

Last sentence of item #5:

Now reads: "If so, use getResponseHeader() or getResponseHeaders() . . ."

Should read, "If so, use getResponseHeader() or getAllResponseHeaders() . . ."

Several typos in the examples have been reported and fixed in the book, but not in the example downloads. For instance, in example 14-2 "Element" is misspelled "Elemnet".

All examples should be corrected as is the book.

BTW, your errata table shows corrections made in 2007 and 2008, and the corrections have been made in my printed 5th edition book, whose printing history is listed as August 2006.