var obj = Object.create(Object.prototype);

var obj2 = {};



// la meme chose

var o = {}; // Creates a new object  

  

Object.defineProperty(o, "a", {value : 37,  

                               writable : false});  

  

alert(o.a); // alerts 37  

o.a = 25;  

alert(o.a); // alerts 37. The assignment didn't work. No error thrown 

// Example of an object property added with defineProperty with an accessor property descriptor  

var bValue;  

Object.defineProperty(o, "b", {get : function(){ return bValue; },  

                               set : function(newValue){ bValue = newValue; },  

                               enumerable : true,  

                               configurable : true});  

o.b = 38;  

// 'b' property exists in the o object and its value is 38  

// The value of o.b is now always identical to bValue, unless o.b is redefined  

var obj = {};  

var obj2 = Object.preventExtensions(obj);  

function letTest() {  

  let x = 31;  

  if (true) {  

    let x = 71;  // different variable  

    alert(x);  // 71  

  }  

  alert(x);  // 31  

}

const FOO = 2;



FOO = 3; // ne fait rien



console.log(FOO); // 2

class Monster {

  // The contextual keyword "constructor" followed by an argument

  // list and a body defines the body of the class’s constructor

  // function. public and private declarations in the constructor

  // declare and initialize per-instance properties. Assignments

  // such as "this.foo = bar;" also set public properties.

  constructor(name, health) {

    public name = name;

    private health = health;

  }

 

  // An identifier followed by an argument list and body defines a

  // method. A “method” here is simply a function property on some

  // object.

  attack(target) {

    log('The monster attacks ' + target);

  }

 

  // The contextual keyword "get" followed by an identifier and

  // a curly body defines a getter in the same way that "get"

  // defines one in an object literal.

  get isAlive() {

    return private(this).health > 0;

  }

 

  // Likewise, "set" can be used to define setters.

  set health(value) {

    if (value < 0) {

      throw new Error('Health must be non-negative.')

    }

    private(this).health = value

  }

 

  // After a "public" modifier,

  // an identifier optionally followed by "=" and an expression

  // declares a prototype property and initializes it to the value

  // of that expression. 

  public numAttacks = 0;

 

  // After a "public" modifier,

  // the keyword "const" followed by an identifier and an

  // initializer declares a constant prototype property.

  public const attackMessage = 'The monster hits you!';

}