5.1   Understanding typeof Operator

6.1   Arithmetic operations

$ node

> 5 + 10
  15

> Math.pow(2, 5)
  32

> 5/3
1.6666666666666667

> Math.floor(5/3)
1

> 5, 7, 21           # or (5, 7, 21)
  21

> a = b = c = 100
  100

> b = (c=5, d=10, 20)   # Embedded assignment in expression is OK.
  20

> 5 < 10
  true

> 5 && 10
  10               // <== It is not a boolean!

> !! (5 && 10)
  true             // <== Use this to convert expr to boolean.

> 5 || 10
  5

> 5 & 1
  1

> 2 << 5
  64

> typeof 5
  'number'

> aaa
  ReferenceError: aaa is not defined

> 2 * 'some'
  NaN

> a++
  100

> a
  101

> ++a
  102

> a += 10
  112

> 6 + '5'        // Integer promoted to string. Not the other way.
  '65'

> parseInt('123Hello')
123

> parseInt('08')      <== Treats as Octal.
0

> parseInt('08', 10)  <== Use Radix always
8

> a = 10; b = 30 ; eval (' a * b ') ;
300

6.2   String Operations

> 'hello ' + ' world'
  "hello  world"

> typeof 'hello'
  'string'

> a = 'hello world'
> a.<Tab>              # Autocomplete works on node.js shell.

  a.__defineGetter__      a.__defineSetter__      a.__lookupGetter__
  a.__lookupSetter__      a.constructor           a.hasOwnProperty
  a.isPrototypeOf         a.propertyIsEnumerable  a.toLocaleString
  a.toString              a.valueOf

  a.anchor                a.big                   a.blink
  a.bold                  a.charAt                a.charCodeAt
  a.concat                a.constructor           a.fixed
  a.fontcolor             a.fontsize              a.indexOf
  a.italics               a.lastIndexOf           a.length
  a.link                  a.localeCompare         a.match
  a.replace               a.search                a.slice
  a.small                 a.split                 a.strike
  a.sub                   a.substr                a.substring
  a.sup                   a.toLocaleLowerCase     a.toLocaleUpperCase
  a.toLowerCase           a.toString              a.toUpperCase
  a.trim                  a.trimLeft              a.trimRight
  a.valueOf

> a.substring(0,5)
  'hello'
> a.substring(5,11)    # a.slice() also does samething with minor differences.
  ' world'
> a.substr(5,6)
  ' world'
> a.length
  11
> typeof a
  'string'

> b = String(123)          # Convert number to primitive string
'123'

> typeof b
  'string'

> b = String('hello world')  # without new operator, it is primitive type.
> a == b
  true

> c = new String('hello world')   # It is now 'object' not 'string' !
> typeof c
  "object"
> a == c        # Primitive object promoted to String to compare true!
  true

6.3   Array Operations

Array is a built-in object of built-in Object type. It can also be used like a type since it defines a constructor.

> a = [1, 2, 3]
> b = [1, 2, 3]
> a == b
false        #  They are different Objects.


> a.push(4)
[1, 2, 3, 4]

> a.unshift(10)           # Push at front
[10, 1, 2, 3, 4]

> a.shift()               # Pop from font
10

> a.concat(b)             # Creates new list a + b
  [1, 2, 3, 1, 2, 3]

> a                       # a remains unchanged.
  [1, 2, 3]

// Note: There is no built-in a.extend(b) method that will mutate a.

> a + b                   # converts to String and joins.
'1,2,31,2,3'              # To join, use concat

> a = [1, 2, 3, 4, 5, 6]
> a.slice(2,4)            # similar to python a[2:4]
[3, 4]                    # a[2], a[3]

>a.<Tab>
a.__defineGetter__      a.__defineSetter__      a.__lookupGetter__      a.__lookupSetter__
a.constructor           a.hasOwnProperty        a.isPrototypeOf         a.propertyIsEnumerable
a.toLocaleString        a.toString              a.valueOf

a.concat                a.constructor           a.every                 a.filter
a.forEach               a.indexOf               a.join                  a.lastIndexOf
a.length                a.map                   a.pop                   a.push
a.reduce                a.reduceRight           a.reverse               a.shift
a.slice                 a.some                  a.sort                  a.splice
a.toLocaleString        a.toString              a.unshift

> a = [10, 20, 30]
[ 10, 20, 30 ]

> delete a[1]          # delete on array element creates hole using 'undefined'
true

> a
[ 10, undefined x 1 , 30 ]

> a[1]
undefined

> a.length             # length remains unchanged.
3

> a.splice(0, 2)       # Really delete 2 elements starting from index 0.
[ 10, undefined x 1 ]

> a
[ 30 ]

> a = [10, 20, 30]
> for (i in a) console.log(i)     # This prints the keys in array.
  0
  1
  2

> a.some    = 200     # Don't mix non-numeric index into array!
> a['abc']  = 300     # This is same as  a.abc = 300
> for (i in a) console.log(i)
  0
  1
  2
  some
  abc

> for (i in a) console.log(typeof(i))
  string
  string
  string
  string
  string              # All indexes stored as string internally.

> c = new Array(10)   # Array is an object as well as a type!
  [undefined × 10]    # Array.constructor defines the type constructor.

> a = [1, 2, 3]; typeof a
"object"

> a instanceof Array
true

> a.constructor
[Function: Array]

6.4   Object Operations

Object is the only non-primitive built-in type.

> a = { 'one' : 1, 'two': 2 }       # Creating object using literal
> typeof a
  "object"

> for (i in a) console.log(i)
  one
  two

> a = new Object()
  Object               # Chrome displays a clickable, explorable empty Object icon.
  {}                   # node.js shell displays the empty object.

> a.v1    = 200        # Perfect for using as associative array.
> a['v2'] = 300        # It is same as a.v2 = 300
> for (i in a) console.log(i)
  v1
  v2

> F = function() { this.var1 = 100; this.var2 = 200 }
> fobj = new F()              # New object created which becomes 'this' object.
  { var1: 100, var2: 200 }

> a.<tab>             # This autocomplete operation works only on node.js shell.

  a.__defineGetter__      a.__defineSetter__      a.__lookupGetter__
  a.__lookupSetter__      a.constructor           a.hasOwnProperty
  a.isPrototypeOf         a.propertyIsEnumerable  a.toLocaleString
  a.toString              a.valueOf

  a.v1                    a.v2

Note: Object does not contain any enumerable properties, hence suitable
for implementing hash/associative array with string keys.

6.5   Prototype Based Inheritance

Javascript supports object based inheritance instead of classes. It makes use of prototype property to trace the parent object hierarchy:

> function  object(o) {
     function F() {}
     F.prototype = o;
     return new F();
  }
> obj = new Object()
> childobj = object(obj)   # childobj is based on parent object obj.

6.6   Misc operations

> typeof true
"boolean"

> a = [1, 2, 3]
> JSON.stringify(a)            # works for nested object as well.
'[1,2,3]'

> di
{ a: 10, b: 20 }


> JSON.stringify(di)
'{"a":10,"b":20}'

> print(JSON.stringify(di, null, 4))     # Nicely formatted output
{
    "a": 10,
    "b": 20
}

> function f() { console.log('hello world') }
undefined

> f.toString()
'function f() { console.log(\'hello world\') }'

> n = null
> n && n.value       # Use this pattern to avoid Null reference.
null

> null == undefined
  true

> null === undefined
  false

6.7   Input/Output

Examples using browser

// alert(), confirm(), prompt() work in browsers.
> alert('hello!!!')
> r = confirm('Press Ok or Cancel')
> r
  true   // or false
> console.log('You pressed ' +  (r && 'OK' || 'Cancel'))
> val = prompt('Enter Value ', '0')
> val
> typeof(val)
  'string'

// Following examples work with node.js

> u=require('util');  u.puts('hello!')  // Prints: 'hello!'
> process.stdout.write('hello!')        // Prints: 'hello!'

// readline will be useful in node.js script, not at the command line:
var readline = require('readline');

var rl = readline.createInterface({
   input: process.stdin,
   output: process.stdout,
   terminal: false
});

rl.on('line', function (cmd) { console.log('You just typed: '+cmd); });

7.1   Overview

Statements can be of following kinds:

Block              VariableStatement  EmptyStatement    ExpressionStatement
IfStatement        IterationStatement ContinueStatement BreakStatement
ReturnStatement    WithStatement      LabelledStatement SwitchStatement
ThrowStatement     TryStatement

7.2   Block Statement

Examples:

{ x++; y++; }
// Note: There is no block level scope for variables.
var x = 1; { var x = 2; } ;  alert(x); // outputs 2

7.3   Variable Statement

function f() { var i = 10; }  // The i is local, not global variable.
function g() {     i = 10; }  // The i is global.

7.4   Expression Statement

a = 10;      //  (a = 10) evaluates to 10. Expression Statement.

7.5   If Statement

if (x == y)
   f(x)
else if (x > z)
   g(x)
else
   h(x)

7.6   Iteration Statement

Examples:

do   x = f(x);  while ( x < 1000 );
while ( notdone ) { f(x); g(x); }
for (a = b+c; a < 10 ; a++ )  f(a);
for ( var i=0; i < a.length ; i++ ) f(a[i]);
for ( i in a )  f(a[i]);
for ( var i in  (c=a.concat(b)) )  f(c[i]);

7.7   Continue and break Statements

outerloop: while (!finished) {
          f(x);
          innerloop: while (!completed) {
            g(x);
            if (condition_1) continue outerloop;
            if (condition_2) break outerloop;
            if (condition_3) continue;
            if (condition_4) break;
            h(x);
          }
       }

7.8   With Statement (deprecated)

with (obj) {
   a = 10;     // set obj.a = 10  if  obj.a exists ; else set global a=10
   b = 20;     // set obj.b = 20  iff obj.b exists;
}
with (document.getElementById("blah").style) {
  background = "black";
  color = "blue";
  border = "1px solid green";
}
// Because of the confusing semantics it is deprecated.

7.9   Switch Statement

// c-style switch but case expression need not be constant!
x = 'hello'; y = 'hell' ; z = 'o';
switch(x)  // Allows strings
{
   case 1   : console.log('it is 1'); break;
   case y+z : console.log('it is y+z'); break;
   default  : console.log('it is default'); break;
}
// Prints: it is y+z

7.10   Try Catch Finally

You can control the error handling by catching errors that are generated. These are the primary error types:

• EvalError: Raised when the eval() functions is used in an incorrect manner.
• RangeError: Raised when a numeric variable exceeds its allowed range.
• ReferenceError: Raised when an invalid reference is used.
• SyntaxError: Raised when a syntax error occurs while parsing JavaScript code.
• TypeError: Raised when the type of a variable is not as expected.
• URIError: Raised when the encodeURI() or decodeURI() functions are used in an incorrect manner.
• Error: User defined errors can be thrown using this. e.g: throw new Error('Timeout!');

When user defined errors are thrown, it is typical to throw Error() object, but you can also simply throw anything like just plain string:

throw new Error('Timeout occurred!');
throw 'Timeout!';

Example:

function f() {
  try {
    val = prompt('Enter Option: 1:Throw; 2:return early; 3:Continue;');
    if (val == '1')
         throw  'Option1-Error-thrown'; // finally will execute.
    else if (val == '2')
         return 'early';                // finally will execute before return.
    else if (val > 3)
         throw  new RangeError('Invalid Option');
  }
  catch (err){
     // You can also do... switch (err.name) ... case 'RangeError': ...;
     // if (typeof err == 'string') then err.name == undefined;
     console.log('Caught error name: ' + err.name);
     console.log('Description:' + err);
  }
  finally{
     console.log('Executing finally now...');
  }
  return 'last';
}