JavaScript: The Good Parts is informative about the bad parts too.
Leaders need to key into the big things happening in their field, so with HTML5 making waves, it seemed the right time to learn JavaScript (JS). JavaScript: The Good Parts is a great reference to JS. It is in the style of great classics such as C Programming Language (2nd Edition)
and The C++ Programming Language (3rd Edition).
The chapters cover JS grammar, how objects work, functions, inheritance and describe the available methods. Crockford describes the areas of JS to avoid such as global variables or JS's handling of Unicode.
and The C++ Programming Language (3rd Edition). The chapters cover JS grammar, how objects work, functions, inheritance and describe the available methods. Crockford describes the areas of JS to avoid such as global variables or JS's handling of Unicode.In most of the chapters the book goes into a good level of detail with great code examples. In a couple of chapters it is a bit vague. For example, the grammer gives good diagrams as well as code examples, but the chapters covering the poorer aspects of JS sometimes just give a description of the problem without workarounds and there are a couple of chapters that feel like filler. Lastly, since the book does not cover the entire language, I also recommend getting JavaScript: The Definitive Guide: Activate Your Web Pages (Definitive Guides).
I've used JavaScript: The Good Parts to help me understand the language better, and I really appreciate its brevity and ease of access. If you want to have a solid reference to the language as well as some good practical advice on best practices and issues to avoid, then this is the book for you.
Just for fun. Here's a bit of code implementing Dijkstra's shortest path.
/* Dijkstra's algorithm */
/* This function is JavaScript's way of creating an object. This object
encapsulates Linked List functionality.
Pass: nothing
Returns: nothing
*/
function gbLinkedList() {
this.head = null;
this.value = null;
function llItem(value) {
this.next = null;
this.value = value;
}
/* This function adds an item to the linked list.
Pass: String, value to be inserted in the list.
Returns: nothing
*/
function addItem(value) {
if (this.head === null) {
this.head = new llItem(value); /* exception case for first item */
return;
}
var currentItem = this.head;
while (currentItem.next !== null) {
currentItem = currentItem.next;
}
currentItem.next = new llItem(value);
}
/* This function finds an item to the linked list.
Pass: String, value to be inserted in the list.
Returns: true if found, false if not found.
*/
function findItem(value) {
var currentItem = this.head;
while (currentItem !== null) {
if (currentItem.value == value) {
return true;
}
else {
currentItem = currentItem.next;
}
}
return false;
}
this.addItem = addItem; // This is required to add the member to the object
this.findItem = findItem;
this.llItem = llItem;
}
/* This function is JavaScript's way of creating an object. This object
encapsulates min heap functionality.
Pass: boolean, if true max heap, if false min heap
Returns: nothing
*/
function gbMinHeap() {
var gbHeapMaxSize = 101; // remember we are wasting entry 0 to save math
var gbNumberOfEntries = 0; // remember we are wasting entry 0 to save math
// This heap does not use the 0th element to avoid -1 to every operation.
var gbHeapArray = new Array(gbHeapMaxSize + 1);
var i;
for (i = 0; i < gbHeapArray.length; i++) { // initialize the heap array.
gbHeapArray[i] = null;
}
function gbPrintHeap() {
var i;
var values = "";
for (i = 1; i < gbNumberOfEntries + 1; i++) {
values = values + gbHeapArray[i].value + ", ";
}
console.log(values);
}
/* This function extracts changes the value of a node
Pass: item, the item whose value is to be changed
value, the new value
Returns: nothing
*/
function reduceValue(item, value) {
item.value = value;
gbMinHeapify(1);
}
/* This function extracts the min from the heap
Pass: nothing
Returns: min, the item with the minimum .value property
*/
function gbExtractMin() {
var min = null;
min = gbHeapArray[1];
gbHeapArray[1] = gbHeapArray[gbNumberOfEntries];
gbHeapArray[gbNumberOfEntries] = null;
gbNumberOfEntries--;
gbMinHeapify(1);
gbPrintHeap();
return min;
}
/* This function inserts an item into the heap
Pass: item, an object with a .value property
Returns: nothing
*/
function gbMinInsert(item) {
var i;
if (item.hasOwnProperty("value")) {
gbNumberOfEntries++;
i = gbNumberOfEntries;
while (i > 1 && gbHeapArray[Math.floor(i / 2)].value > item.value) {
gbHeapArray[i] = gbHeapArray[Math.floor(i / 2)];
i = Math.floor(i / 2);
}
}
gbHeapArray[i] = item;
gbPrintHeap();
}
/* This repairs the property of the min heap at the current node
Pass: index, the parent to fix
Returns: nothing
*/
function gbMinHeapify(index) {
var left = 2 * index;
var right = 2 * index + 1;
var smallestIndex = 0;
var temp = 0;
if (gbHeapArray[left] !== null && gbHeapArray[index] !== null) { // left and index have values
if (gbHeapArray[left].value < gbHeapArray[index].value) { // Choose the smallest
smallestIndex = left;
}
else {
smallestIndex = index;
}
if (gbHeapArray[right] !== null && gbHeapArray[right].value < gbHeapArray[smallestIndex].value) {
smallestIndex = right;
}
if (smallestIndex !== index) {
temp = gbHeapArray[index];
gbHeapArray[index] = gbHeapArray[smallestIndex];
gbHeapArray[smallestIndex] = temp;
gbMinHeapify(smallestIndex);
}
}
}
this.gbExtractMin = gbExtractMin;
this.gbMinInsert = gbMinInsert;
this.reduceValue = reduceValue;
}
/* This function is JavaScript's way of creating an object. This object
encapsulates a heap node for the test.
Pass: item, an object with a .value property
Returns: nothing
*/
function gbHeapNode(value) {
this.value = value;
}
function gbEdge(vertice, value) {
this.edgeVertice = vertice;
this.value = value;
}
function gbVertice(index) {
this.value = 0; // this is dist.
this.index = index;
this.neighbors = null;
}
/* This function is JavaScript's way of creating an object. This object
encapsulates a Dijstra's algorithm for shortest path.
Pass: graph, an array of objects with linked lists for neighbors
s, index of start point.
Returns: nothing
*/
function gbDijkstra() {
var priorityQueue = null;
var dist = null;
var prev = null;
function gbFindPath(graph, s) {
priorityQueue = new gbMinHeap();
dist = new Array(graph.length);
prev = new Array(graph.length);
var i;
var currentNeighbor = null;
var currentVertice = null;
var currentWeight = 0;
var newLength = 0;
for (i = 0; i < dist.length; i++) {
dist[i] = graph[i].value = 1000000000;
prev[i] = null;
}
dist[s] = graph[s].value = 0;
for (i = 0; i < dist.length; i++) {
priorityQueue.gbMinInsert(graph[i]); // insert the items in priority order
}
currentVertice = priorityQueue.gbExtractMin(); // get the vertice with the smallest dist
while (currentVertice !== null) {
currentNeighbor = currentVertice.neighbors.head; // start at the first neighbor
while (currentNeighbor !== null) {
currentWeight = currentNeighbor.value.value; // get the weight of the edge
newLength = dist[currentVertice.index] + currentWeight; // Add it to the current shortest distance stored for that vertice
if (newLength < dist[currentNeighbor.value.edgeVertice.index]) {
priorityQueue.reduceValue(currentNeighbor.value.edgeVertice, newLength);
dist[currentNeighbor.value.edgeVertice.index] = graph[currentNeighbor.value.edgeVertice.index].value = newLength;
prev[currentNeighbor.value.edgeVertice.index] = currentVertice;
}
currentNeighbor = currentNeighbor.next;
}
gbPrintGraph();
currentVertice = priorityQueue.gbExtractMin(); // get the next vertice
}
}
function gbPrintGraph() {
var tempS = "";
for(i=0;i<dist.length;i++) {
tempS = tempS + i + ":" + dist[i] + ", ";
}
console.log("Dist: "+tempS);
tempS = "";
for(i=0;i<prev.length;i++) {
if(prev[i] !== null) {
tempS = tempS + i + ":" + prev[i].index + ", ";
}
}
console.log("Prev: "+tempS);
}
this.gbFindPath = gbFindPath;
}
// Test
var myGraph = Array(5);
var i;
for (i = 0; i < myGraph.length; i++) {
myGraph[i] = new gbVertice(i); // label the vertices
}
var edge = null;
var ll = null;
// create edges to be inserted into gbVertice 0
ll = new gbLinkedList();
edge = new gbEdge(myGraph[1], 2);
ll.addItem(edge);
edge = new gbEdge(myGraph[4], 4);
ll.addItem(edge);
myGraph[0].neighbors = ll;
// create edges to be inserted into gbVertice 1
ll = new gbLinkedList();
edge = new gbEdge(myGraph[2], 3);
ll.addItem(edge);
myGraph[1].neighbors = ll;
// create edges to be inserted into gbVertice 2
ll = new gbLinkedList();
edge = new gbEdge(myGraph[4], 1);
ll.addItem(edge);
edge = new gbEdge(myGraph[3], 5);
ll.addItem(edge);
myGraph[2].neighbors = ll;
// create edges to be inserted into gbVertice 3
ll = new gbLinkedList();
edge = new gbEdge(myGraph[0], 8);
ll.addItem(edge);
myGraph[3].neighbors = ll;
// create edges to be inserted into gbVertice 4
ll = new gbLinkedList();
edge = new gbEdge(myGraph[3], 7);
ll.addItem(edge);
myGraph[4].neighbors = ll;
var myDijkstra = new gbDijkstra();
myDijkstra.gbFindPath(myGraph, 0);
great
ReplyDelete