var my_string = "I am a string";

const my_other_string = "0042"; // still a string 

let my_number = 42;

const i_am_null = null;


my_string.toUpperCase(); 
// "A STRING"
console.log(my_string); // a string
function add_one(my_number){
  my_number += 2; // a new var is created here!
}
console.log(my_number); // 2
add_one(my_number); 
console.log(my_number); // still 2!

function fn(){
  var num = 5; // function scope
  let unused = 69; // block (=function) scoped
  if (num === 5) {
    let a = num + 2; // block scope
    const b = num + a; // block scope
    console.log(num, a, b); // 5, 7, 12
  }
  console.log(num); // 5
  console.log(a); // ReferenceError: a is not defined
                  // because a is block scoped to the `if`
  console.log(b); // We' ll never make it here :( 
}

fn();

console.log(x); // undefined
var x = 5;

// What the computer understands
var x;
console.log(x);
x = 5;

console.log(a);
let a = 2;
// ff: ReferenceError: can't 
//   access lexical declaration
//   `a' before initialization
// ch: Uncaught ReferenceError:
//   a is not defined

var x = 2;
function foo(){
  console.log(x);
  let x = 3;
}
foo();
// same error BUT...
// if let didn't hoist
//   it would print "2"

// literal
var o = {
  name: 'papas'
};

// with constructor
var oo = new Object({
  name:'papas'
});
console.log(o);

function inc(num) {
  // do something
  return num + 1;
}

console.log(inc.prototype);

var Car = function(name){
  this.name = name;
  this.toString = function() {
    return 'I am defined in the constructor! I am a ' + this.name;
  };
};
console.log(Car.prototype); // shows an Object with only constructor
Car.prototype.toString = function() {
  return 'hello from prototype. I am a ' + this.name;
};
var honda = new Car('Honda');
var tesla = new Car('Tesla');
console.log(tesla + ''); // I am defined in the constructor! I am a Tesla
tesla.toString = function(){
  return 'hello from the ' + this.name + ' instance!';
};
console.log(tesla + ''); // hello from the Tesla instance!
console.log(honda + ''); // I am defined in the constructor! I am a Honda
delete tesla.toString;
console.log(tesla + ''); // hello from prototype. I am a Tesla!
delete Car.prototype.toString;
console.log(tesla + ''); // [object Object]

const john = {
  name: 'John'
};

function setname_george(o) {
  o.name = 'George';
  return o;
}

console.log(john); // {name: "John"}

const george = setname_george(john);
console.log(george); // {name: "George"} Seems legit
console.log(john); // {name: "George"} We fckd up john

const person = {
  name: 'John'
};

const data = {
  person: person
};

person.name = 'George';
console.log(data); 
// {person: {name: 'George'}}
// data is an Object.
// It holds a reference to another object, `person`.
// when `person` changes, `data` changes too...

const data = {
  person: {
    name: 'John'
  }
};

const person = data.person;
person.name = 'George';

console.log(data); 
// {person: {name: 'George'}}
// data is an Object.
// It holds a reference to another object, `person`.
// when `person` changes, `data` changes too...

const data = {
  person: {
    name: 'John'
  }
};

const person = data.person;
delete data.person;

console.log(data); 
// {}
// reference of `person` was deleted from `data` 

console.log(person); 
// {name: 'John'}
// this reference still exists!

function Person () {
  this.hobbies = ['sitting', 'sleeping'];
}

Person.prototype = {
  first: 'John', last: 'Doe',
  fullname: function(){
    return this.first_name + ' ' + this.last_name;
  }
};

const jd = new Person(), ml = new Person();
ml.first = 'Mary'; ml.last = 'Lamb';

ml.hobbies[1] = 'running';
console.log(ml.hobbies); // ["sitting", "running"]
console.log(jd.hobbies); // ["sitting", "sleeping"] yup, that's me