add error_handling

Author: completejavascript

Error_Handling/Retry_completejavascript.com.js

@@ -0,0 +1,28 @@
+function MultiplicatorUnitFailure() {}
+
+function primitiveMultiply(a, b) {
+  if (Math.random() < 0.5)
+    return a * b;
+  else
+    throw new MultiplicatorUnitFailure();
+}
+
+function reliableMultiply(a, b) {
+  var result;
+  while(true){
+    try{
+      result = primitiveMultiply(a, b);
+      break;
+    }catch(error){
+      if(error instanceof MultiplicatorUnitFailure){
+        console.log("Error: MultiplicatorUnitFailure");
+      }else{
+        throw error;
+      }
+    }  
+  }
+  return result;
+}
+
+console.log(reliableMultiply(8, 8));
+// => 64

Error_Handling/The_locked_box_completejavascript.com.js

@@ -0,0 +1,33 @@
+var box = {
+  locked: true,
+  unlock: function() { this.locked = false; },
+  lock: function() { this.locked = true;  },
+  _content: [],
+  get content() {
+    if (this.locked) throw new Error("Locked!");
+    return this._content;
+  }
+};
+
+function withBoxUnlocked(body) {
+  if(box.locked) box.unlock(); 
+  try{
+    body();
+  }finally{
+    box.lock();
+  }
+}
+
+withBoxUnlocked(function() {
+  box.content.push("gold piece");
+});
+
+try {
+  withBoxUnlocked(function() {
+    throw new Error("Pirates on the horizon! Abort!");
+  });
+} catch (e) {
+  console.log("Error raised:", e);
+}
+console.log(box.locked);
+// => true

practice/Electronic_life_completejavascript.com.js

@@ -0,0 +1,183 @@
+var plan = ["############################",
+            "#      #    #      o      ##",
+            "#                          #",
+            "#          #####           #",
+            "##         #   #    ##     #",
+            "###           ##     #     #",
+            "#           ###      #     #",
+            "#   ####                   #",
+            "#   ##       o             #",
+            "# o  #         o       ### #",
+            "#    #                     #",
+            "############################"];
+
+function Vector(x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+Vector.prototype.plus = function(other) {
+  return new Vector(this.x + other.x, this.y + other.y);
+};
+
+function Grid(width, height) {
+  this.space = new Array(width * height);
+  this.width = width;
+  this.height = height;
+}
+Grid.prototype.isInside = function(vector) {
+  return vector.x >= 0 && vector.x < this.width &&
+         vector.y >= 0 && vector.y < this.height;
+};
+
+Grid.prototype.get = function(vector) {
+  return this.space[vector.x + this.width * vector.y];
+};
+
+Grid.prototype.set = function(vector, value) {
+  this.space[vector.x + this.width * vector.y] = value;
+};
+
+var directions = {
+  "n":  new Vector( 0, -1),
+  "ne": new Vector( 1, -1),
+  "e":  new Vector( 1,  0),
+  "se": new Vector( 1,  1),
+  "s":  new Vector( 0,  1),
+  "sw": new Vector(-1,  1),
+  "w":  new Vector(-1,  0),
+  "nw": new Vector(-1, -1)
+};
+
+function randomElement(array) {
+  return array[Math.floor(Math.random() * array.length)];
+}
+
+var directionNames = "n ne e se s sw w nw".split(" ");
+
+function BouncingCritter() {
+  this.direction = randomElement(directionNames);
+};
+
+BouncingCritter.prototype.act = function(view) {
+  if (view.look(this.direction) != " ")
+    this.direction = view.find(" ") || "s";
+  return {type: "move", direction: this.direction};
+};
+
+function elementFromChar(legend, ch) {
+  if (ch == " ")
+    return null;
+  var element = new legend[ch]();
+  element.originChar = ch;
+  return element;
+}
+
+function World(map, legend) {
+  var grid = new Grid(map[0].length, map.length);
+  this.grid = grid;
+  this.legend = legend;
+
+  map.forEach(function(line, y) {
+    for (var x = 0; x < line.length; x++)
+      grid.set(new Vector(x, y),
+               elementFromChar(legend, line[x]));
+  });
+}
+
+function charFromElement(element) {
+  if (element == null)
+    return " ";
+  else
+    return element.originChar;
+}
+
+World.prototype.toString = function() {
+  var output = "";
+  for (var y = 0; y < this.grid.height; y++) {
+    for (var x = 0; x < this.grid.width; x++) {
+      var element = this.grid.get(new Vector(x, y));
+      output += charFromElement(element);
+    }
+    output += "\n";
+  }
+  return output;
+};
+
+function Wall() {}
+
+var world = new World(plan, {"#": Wall,
+                             "o": BouncingCritter});
+
+Grid.prototype.forEach = function(f, context) {
+  for (var y = 0; y < this.height; y++) {
+    for (var x = 0; x < this.width; x++) {
+      var value = this.space[x + y * this.width];
+      if (value != null)
+        f.call(context, value, new Vector(x, y));
+    }
+  }
+};
+
+World.prototype.turn = function() {
+  var acted = [];
+  this.grid.forEach(function(critter, vector) {
+    if (critter.act && acted.indexOf(critter) == -1) {
+      acted.push(critter);
+      this.letAct(critter, vector);
+    }
+  }, this);
+};
+
+World.prototype.letAct = function(critter, vector) {
+  var action = critter.act(new View(this, vector));
+  if (action && action.type == "move") {
+    var dest = this.checkDestination(action, vector);
+    if (dest && this.grid.get(dest) == null) {
+      this.grid.set(vector, null);
+      this.grid.set(dest, critter);
+    }
+  }
+};
+
+World.prototype.checkDestination = function(action, vector) {
+  if (directions.hasOwnProperty(action.direction)) {
+    var dest = vector.plus(directions[action.direction]);
+    if (this.grid.isInside(dest))
+      return dest;
+  }
+};
+
+function View(world, vector) {
+  this.world = world;
+  this.vector = vector;
+}
+
+View.prototype.look = function(dir) {
+  var target = this.vector.plus(directions[dir]);
+  if (this.world.grid.isInside(target))
+    return charFromElement(this.world.grid.get(target));
+  else
+    return "#";
+};
+
+View.prototype.findAll = function(ch) {
+  var found = [];
+  for (var dir in directions)
+    if (this.look(dir) == ch)
+      found.push(dir);
+  return found;
+};
+
+View.prototype.find = function(ch) {
+  var found = this.findAll(ch);
+  if (found.length == 0) return null;
+  return randomElement(found);
+};
+
+for (var i = 0; i < 5; i++) {
+  world.turn();
+  console.log(world.toString());
+}
+
+//animateWorld(world);

test.html

@@ -1,29 +1,22 @@
 <!DOCTYPE html>
 <html>
 <head>
-  <script>
-    function f1(number){
-		if(number == 0 || number == 1) return 1;
-		return f1(number - 1) + f1(number - 2);
-	}
-
-	function f2(number){
-		if(number == 0 || number == 1) return 1;
-
-		var a2 = 1, a1 = 1, a;
-		for(i = 2; i <= number; i++){
-	 		a = a1 + a2;
-	 		a2 = a1;
-	 		a1 = a;
-		}
-
-		return a;
-	}
-
-	console.log(f1(6));
-	console.log(f2(6));
-
-  </script>
+<title></title>
+<script src="./practice/Electronic_life_completejavascript.com.js">
+/*
+var test = {
+  prop: 10,
+  addPropTo: function(array) {
+    return array.map(function(elt) {
+      return this.prop + elt;
+    }.bind(this));
+  }
+};
+console.log(test.addPropTo([5]));
+*/
+</script>
 </head>
-<body></body>
-</html>
+<body>
+
+</body>
+</html>