The document discusses the history and evolution of JavaScript, including its origins from Java and LiveScript, standardization as ECMAScript, and key features such as dynamic typing, objects, functions, and prototypal inheritance. It also covers JavaScript data types like numbers, strings, Booleans, objects, and functions, and how the language handles values, scope, operators, and other elements.

1. Mohammed Irfan

2.  JavaScript is a stripped down version of Java
 JavaScript does not exist outside browsers
 JavaScript is inconsistent and buggy
 JavaScript is not object-orientated

3.  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

4.  Semicolon insertion
 typeof and instanceof
 with and eval
 == and !=
 new

5.  Loose Typing
 Dynamic Objects
 Object / Array Literals
 Functions / Lambdas

6.  Self
 prototypal inheritance
 dynamic objects
 Scheme
 lambda
 loose typing
 Java
 syntax
 conventions
 Perl
 regular expressions

7.  Numbers
 Strings
 Booleans
 Objects
 Functions

8.  Number
 String
 Boolean
 Object
 Function
 Array
 Date
 RegExp
 Null
 Undefined

9.  Only one number type
 No integers
 64-bit floating point IEEE-754 (aka “Double”)
 Numbers are Objects

10. (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

11. a = 0.1;
b = 0.2;
c = 0.3;
(a + b) + c === a + (b + c)
> false

12.  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

13.  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

14. > "hello".charAt(0)
h
> "hello, world".replace("hello",
"goodbye")
goodbye, world
> "hello".toUpperCase()
HELLO

15.  null = deliberately no value
 undefined = no value assigned yet
 Variables declared but not initialized
 Object/array members that don't exist

16.  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 !

17.  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

18. var obj = new Object();
Or
var obj = {};
These are semantically equivalent; the second is
called object literal syntax and is more
convenient.

19. 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)

20. var obj = {
name: "Carrot",
"for": "Max",
details: {
color: "orange",
size: 12
}
}
> obj.details.color
Orange
> obj["details"]["size"]
12

21. 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

22.  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.length
3
 No such thing as “Associative Arrays”

23. More convenient notation:
> var a = ["dog", "cat", "hen"];
> a.length
3
var a = [10, "dog", false, "elephant"];
(you can have mixed content in arrays)

24. > 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;

25.  New variables are declared using the var
keyword:
 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.

26.  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

27. var a;
//...
function F() {
var b;
//...
function N() {
var c;
//...
};
}

28.  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

29. 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

30.  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

31. 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

32. $('#some-id').click(function(evt) {
// do something on click event
};

33. var add = function(x) {
return function(y) {
return x + y;
};
};

34. function Person(name) {
this.name = name;
this.getName = function() {
return this.name;
};
}
var person = new Person("some one");
person.getName();
> some one