This document summarizes some key aspects of JavaScript including: - JavaScript's basic language features like functions, objects, and exceptions. - The good parts of JavaScript like first-class functions, object literals, closures, and prototyping which enable powerful programming patterns. - The bad parts like inconsistent cross-browser support, eval(), tricky truthiness rules, and missing declarations which can cause bugs. - That following good coding practices, using common sense, and static analysis can help address JavaScript's weaknesses.

1. JavaScript
Java is to JavaScript as ham is to hamster

2. • The basic language
• The good parts
• The bad parts
• The salvation

3. The basic language
Do what I mean

4. alert(”Hello world”);

5. function fib(n) {
if (n == 1 || n == 2) {
return 1;
}
return fib(n-1) + fib(n-2);
}
alert(fib(100));

6. var burt = new Person();
burt.age = 2;
burt.father = ”Gustav”;

7. try {
var input = prompt();
if (input <= 0) {
throw ”Natural plz”;
}
alert(fib(input));
} catch (ex) {
alert(”Doh: ” + ex);
}

8. var s1 = ”a ‘quoted’ string”;
var s2 = ’a ”quoted” string’;
var s3 = ”a ‘quoted” string”;

9. var a1 = [2, 3, 5, 7, 11];
var a2 = [”foo”, ”bar”];
var a3 = [2, ”foo”, null];

10. var p = /^[A-Z][a-z]*$/;
alert(”Jakob”.match(p));
alert(”iPhone”.match(p));

11. The good parts
First-class functions, object literals, closures, prototyping
and dynamic arguments

12. First-class functions

13. var burt = new Person();
burt.age = 2;
burt.father = ”Gustav”;
burt.tellAge = function() {
alert(”Age: ” + this.age);
}
burt.tellAge();
burt.age = 3;
burt.tellAge();

14. var p = [2, 3, 5, 7, 11];
alert(p.filter(function(x) {
return x & 1 == 0;
}));

15. get(”jsonip.com”, function(x) {
alert(x);
});

16. Object literals

17. var burt = {
age: 2,
father: ”Gustav”,
tellAge: function() {
alert(”Age: ” + this.age);
},
employees: [”Jakob”, ... ]
}
var whichOne = prompt();
alert(burt[whichOne]);

18. for (var property in burt) {
alert(property);
alert(burt[property]);
}

19. burt.lookMom = ”a new value!”;
alert(Object.keys(burt));
alert(Object.values(burt));

20. var json = {
”xml”: ”no”,
”json”: true,
”numbers”: [1, 2, 3],
”functions”: false,
”recursive”: {
”guess”: ”Hell yeah!”
}
}

21. Closures

22. class Counter {
private int x = 0;
public void count() {
return x++;
}
}
var c1 = new Counter();
var c2 = new Counter();
var a = [c1.count(),
c1.count(),
c2.count()];
alert(a);

23. function counter() {
var x = 0;
var f = function() {
return x++;
}
return f;
}
var c1 = counter();
var c2 = counter();
var a = [c1(), c1(), c2()];
alert(a);

24. • C lets us forget stacks, heaps and jumps
• Java lets us forget memory management
• JavaScript lets us forget creating state

25. Prototyping

26. function Animal(name) {
this.name = name;
this.talk = function() {
alert(this.name + ”: huh?”);
}
}
var a = new Animal(”garfield”);
var b = new Animal(”lassie”);
alert(a.name);
alert(b.talk());

27. function Animal(name) {
this.name = name;
}
Animal.prototype.talk = f() {
alert(this.name + ”: huh?”);
}
var a = new Animal(”garfield”);
var b = new Animal(”lassie”);
alert(a.name);
alert(b.talk());

28. function clone(o) {
function F() {}
F.prototype = o;
return new F();
}

29. var animal = { };
animal.talk = function() {
alert(this.name + ": huh?");
};
var cat = clone(animal);
cat.talk = function() {
alert(this.name + ": meow!");
}
var a = clone(cat);
a.name = "garfield";
a.talk();

30. The bad parts
The bad and the ugly

31. IE6

32. The DOM

33. eval

34. var sum = eval(”1 + 4”);
eval(”var x = 10”);
eval(”alert(x + sum)”);

35. • Opens up the code for injection attacks
• Debugging becomes hell
• Slow execution

36. Tricky truthiness

37. if (x) {
alert(”when?”);
}

38. • Not null
• Not undefined
• Not false
• Not 0
• Not the empty string

39. Missing ”var”

40. // Style #1
function foobar() {
x = 10;
}
// Style #2
function foobar() {
var x = 10;
}
// Style #3
var x;
function foobar() {
x = 10;
}

41. fs.readFileSync(
sourceDir + "/" + files[i],
encoding = "utf8"
);

42. Silly semicolon
insertion

43. function foobar() {
var x = 1 + 2
return x
}

44. function foobar() {
var x = 1 + 2;
return
x;
}

45. with

46. with(burt) {
alert(age);
alert(father);
}

47. with(burt) {
age = 3;
foo = ”bar”;
}

48. parseInt

49. var a = parseInt(”123”);
var b = parseInt(”110”, 2);
var c = parseInt(”0123”);

50. Everything is an object
(except when parsing numbers)

51. alert(x.toString());
alert(1.toString());

52. alert(1.0.toString());

53. alert(1..toString());

54. alert((1).toString());

55. The salvation
Good coding practices, common sense & static analysis