the javascript programming language

Mohammed Irfan

JavaScript is a stripped down version of Java

JavaScript does not exist outside browsers

JavaScript is inconsistent and buggy

JavaScript is not object-orientated

Birth of Mocha, then rename to LiveScript

Netscape and Sun collaboration for Java in browsers;

LiveScript gets renamed to JavaScript

IE team reverse engineers JavaScript to JScript

Browser war begins

Standardization of JavaScript at ECMA; ECMAScript becomes the official name

Rise of Ajax

JavaScript libraries emerge

ECMAScript 5

Semicolon insertion

typeof and instanceof

with and eval

== and !=

new

Loose Typing

Dynamic Objects

Object / Array Literals

Functions / Lambdas

Self

prototypal inheritance

dynamic objects

Scheme

lambda

loose typing

Java

syntax

conventions

Perl

regular expressions

Numbers

Strings

Booleans

Objects

Functions

Number

String

Boolean

Object Function

Array

Date

RegExp

Null

Undefined

Only one number type

No integers

64-bit floating point IEEE-754 (aka “Double”)

Numbers are Objects

(a + b) + c === a + (b + c)

Produces false for some values of a, b, c.

Integers under 9007199254740992 (9

quadrillion) are ok.

9007199254740992 === 9007199254740992 + 1

a = 0.1;

b = 0.2;

c = 0.3;

(a + b) + c === a + (b + c)

> false

Special number: Not a Number

Result of undefined or erroneous operations

Toxic: any arithmetic operation with NaN as an

input will have NaN as a result

NaN is not equal to anything, including NaN

NaN === NaN is false

NaN !== NaN is true

A sequence of 0 or more 16-bit Unicode

characters

No separate character type

Characters are represented as strings with length

of 1

Strings are immutable

Similar strings are equal ( === )

String literals can use single or double quotes with

\ escapement.

Strings are Objects

> "hello".charAt(0)

h

> "hello, world".replace("hello", "goodbye")

goodbye, world

> "hello".toUpperCase()

HELLO

null = deliberately no value

undefined = no value assigned yet

Variables declared but not initialized

Object/array members that don't exist

Boolean type: true or false

Everything else is “truthy” or “falsy”

0, "", NaN, null and undefined are falsy

Everything else is truthy

Boolean operations: &&, || and !

Simple key-value pairs, like:

HashMaps in Java

Associative arrays in PHP

Key is a string; value can be anything

Key is unique within an object

var obj = new Object();

Or

var obj = {};

These are semantically equivalent; the second is

called object literal syntax and is more

convenient.

obj.name = "My Name"

var name = obj.name;

Or

obj["name"] = "My Name";

var name = obj["name"];

Semantically equivalent; the second uses strings

so can be decided at run-time (and can be

used for reserved words)

var obj = {

name: "Carrot",

"for": "Max",

details: {

color: "orange",

size: 12

}

}

> obj.details.color

Orange

> obj["details"]["size"]

12

Iterate over the keys of an object:

var obj = { 'name': 'Simon', 'age': 25 };

for (var attr in obj) {

alert (attr + ' = ' + obj[attr]);

}

Not to be used with Arrays

A special type of object: Keys are whole numbers, not strings.

Use [] syntax, just like objects

> var a = new Array();> a[0] = "dog";> a[1] = "cat";> a[2] = "hen“;> a.length3 No such thing as “Associative Arrays”

More convenient notation:

> var a = ["dog", "cat", "hen"];

> a.length

3

var a = [10, "dog", false, "elephant"];

(you can have mixed content in arrays)

> var a = ["dog", "cat", "hen"];

> a[100] = "fox";

> a.length

101

typeof a[90] == 'undefined'

array.length is always one more than the highest index

The safest way to append new items is:

a[a.length] = item;

New variables are declared using the varkeyword:

var a;

var name = "my name";

If you declare a variable without assigning it to

anything, its value is undefined.

If you forget the var, you get a global variable.

Never, ever do this – not even if you mean it.

Global variables are visible everywhere

Blocks do not have scope

Variables defined inside blocks are hoisted to

the top and are visible outside the block

Functions have scope

Variables defined inside function are visible

throughout the function and its inner functions

var a;

//...

function F() {

var b;

//...

function N() {

var c;

//...

};

}

Three different purposes of functions: as sub-routine / procedure

as lambda (a block of executable code)

as object constructor

Functions are first-class: can be assigned to a variable

can be passed as argument to any function

can be returned from any function

can be a member of any object

can be created at run time

Functions can be created inside another function

function add(x, y) {

var total = x + y;

return total;

}

var add = function(x, y) {

var total = x + y;

return total;

};

var add = function some_func(x, y) {

var total = x + y;

return total;

};

If nothing is explicitly returned, return value is undefined

Parameters: “They’re more like... Guidelines”

Missing parameters are treated as undefined:

> add()

NaN // addition on undefined

You can pass in more arguments than

expected:

> add(2, 3, 4)

5 // added the first two; 4 was ignored

The arguments special variable provides access to arguments as an array-like object

function add() {

var sum = 0;

for (var i = 0, j = arguments.length; i < j; i++) {

sum += arguments[i];

}

return sum;

}

> add(2, 3, 4, 5)

14

$('#some-id').click(function(evt) {

// do something on click event

};

var add = function(x) {

return function(y) {

return x + y;

};

};

function Person(name) {

this.name = name;

this.getName = function() {

return this.name;

};

}

var person = new Person("some one");

person.getName();

> some one