Sundarrajk's Weblog

JavaScript – The Good Parts – Part 5

Posted on: January 10, 2013


Introduction

This is the fifth post based on the book JavaScript – The Good Parts by Douglas Crockford. The previous post covered details like Closures and Modules. This section covers Curry, some Gotcha in JavaScript, Exceptions and With.

Curry

This allows one to create a new function using an existing function with one or more arguments having a specific value.
Setup the curry function

Function.method ('curry', function () {
var slice = Array.prototype.slice, args = slice.apply(arguments), that = this;
return function () {
return that.apply(null, args.concat(slice.apply(arguments)));
};
});

Now use this as follows:

var add = add.curry(1);
add1(6); //returns 7

In this manner we can create new functions from existing functions by providing value to one or more of the arguments.

Gotcha

JavaScript does not require one to put a semicolon, but this can lead to some unexpected surprises. Consider this function.

a = function () {
return
{
ok: false;
};
}

One expects this method to return an object with an attribute “ok” with value “false”. But what this actually returns is “undefined”. This happens because of the way JavaScript introduces “;”. Since there is no semicolon after the keyword “return”, JavaScript will put a semicolon after “return” and return “undefined”. The rest of the code is ignored.

Converting Strings to Integers

One way to convert String values to integers is to use parseInt(. The other way to do this would be to compute as follows:

X = 3 + (+"4"); //X = 7
X = 3 + "4"; //X = 34

Exceptions

JavaScript can throw Exception in case of errors. The following are the type of exceptions:
One can throw an exception as follows:

throw new Error(reason);

or

throw {
name: exceptionName;
message: reason;
}

One can use a standard try … catch statement to catch Exceptions

try {
} catch (e) {
switch(e.name) {
case ‘Error’:

break;
default:
throw e;
}
}

There is only one catch clause as there are no Exception classes.

  • Error
  • EvalError
  • RangeError
  • SyntaxError
  • TypeError
  • URIError

With

With can be used to reduce the coding by indicating that we wish to work with attributes/functions of a specified object. But it does not work seamlessly and should be avoided.

with(o) {
foo = koda;
}

Which of the following is true:

o.foo = koda;
o.foo = o.koda;
foo = o.koda;
foo = koda;

What it actually does is this

if ('foo' in o) {
o.foo = 'koda' in o ? o.koda : koda;
} else {
foo = 'koda' in o ? o.koda : koda;
}

Which is logical but given the complexity of the logic, it is better avoided.

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

Categories

Advertisements
%d bloggers like this: