Errata

The BFS function is never called in any of these programs - even inside the book.

Note from the Author or Editor:
* Text corrected in copy *

The bfs function is called in some of the applications, but wasn't called in the others. The text has been corrected. The examples have also been corrected and will be rolled out in a couple of weeks.

This is the current example in the PDF:

var nums = [1,2,3,7,8,9];
var newElements = [4,5,6];
nums.splice(3,0,newElements);
print(nums); // 1,2,3,4,5,6,7,8,9

When adding an array of data using splice(), it will be added as an array, so the results would is going to be:

print(nums); // [1, 2, 3, [4, 5, 6], 7, 8, 9]

Note from the Author or Editor:
*Errata has been confirmed, and fix has been incorporated into text"

Should be:

nums.splice(3,0,4,5,6);

The code example for Clear: Removing All Elements from a List shows:
function clear() {
delete this.dataStore;
this.dataStore = [];
this.listSize = this.pos = 0;
}

The problem is that this.dataStore = [] is not the correct way to clear an array. It should be this.dataStore.length = 0

Any reference to the List or to the datastore will contain the old values if this.dataSTore = [] is used.

Note from the Author or Editor:
*This item has been fixed in the text*

Reviewer is correct, it should have been this.dataStore.length = 0;

function dequeue() {
var priority = this.dataStore[0].code;
for (var i = 1; i < this.dataStore.length; ++i) {
if (this.dataStore[i].code < priority) {
priority = i;
}
}
return this.dataStore.splice(priority,1);
}

and the accompanying output does not actually return the lowest code patient in the queue as the text suggests it should. You will see in the output that Jones, with code 4 is treated first, when it is Brown with code 1 that should be first.

The dequeue function, in order to work as suggested should read as follows:

function dequeue() {
var priority = 0
for (var i = 1; i < this.dataStore.length; i+=1) {
if (this.dataStore[i].code < this.dataStore[priority].code) {
priority = i;
}
}
return this.dataStore.splice(priority,1);
}

Note from the Author or Editor:
* Corrected in text*

The dequeue function has been redefined to:

function dequeue() {
var entry = 0;
for (var i = 0; i < this.dataStore.length; ++i) {
if (this.dataStore[i].code < this.dataStore[entry].code) {
entry = i;
}
}
return this.dataStore.splice(entry,1);
}

Matching errata's submitter design, with minor name change

The use of an array in this manner is a serious misunderstanding of JavaScript's way of implementing arrays.

The example states that "JavaScript can't sort the property [keys] of an Object", yet later in the chapter it is stated that string keys don't work and that Object.keys() has to be used.

what this:

this.datastore[key] = value;

does, is that it defines a new property on the object this.datastore, (and for that matter even works if this.datastore is of type Number or String). There is no and has never been any support in arrays for string keys, and saying so is teaching your readers wrongly.

That has nothing to do with sorting or searching, it just conveys the wrong idea.

Also see

http://stackoverflow.com/questions/9526860/why-does-a-string-index-in-a-javascript-array-not-increase-the-length-size

on an explanation why it's a bad idea to use strings on arrays: because then, there is no reliable "length" property as there are no "string indexes" at all. Just use Objects.

Note from the Author or Editor:
* Clarification made directly into text *

Array access notation is an approach to dealing with key-value pairs in JavaScript. Added clarifying text, and some corrections into the code to ensure reader knows we're dealing with objects, not arrays.