let salary = 30000;

let overtime = 10;

let rate = 20;

function getWage(salary, overtime, rate) {

return salary + (overtime * rate);

}

let employee = {

salary: 30000,

overtime: 10,

rate: 20,

getWage: function() {

return this.salary + (this.overtime * this.rate);

}

};

employee.getWage();

const car = {

make: "honda", // string

wheels: 4, // number

isWorking: true, // boolean

startIgnition: function() { // "method" or function

console.log("vroom")

},

options: { // object

airCon: true,

sportExhaust: true,

spareTire: false,

},

seats: ["driver", "passenger", "rear"] // array

};

console.log(car.make); //=> honda

console.log(car.wheels); //=> 4

console.log(car.isWorking); //=> true

console.log(car.startIgnition()); //=> vroom

console.log(car.options); //=> { airCon: true, sportExhaust: true, spareTire: false }

console.log(car.seats); //=> [ 'driver', 'passenger', 'rear' ]

function createCar(make) { // using the function 'createCar' (passing in make)...

}

const makeAcura = createCar('acura'); // create a 'makeAcura' object from the createCar factory,

console.log(makeAcura); // { make: 'acura',

// isWorking: true,

// startIgnition: [Function: startIgnition] }

function MakeAnotherCar(make) {

}

const makeFord = new MakeAnotherCar('ford');

console.log(makeFord); // MakeAnotherCar { make: 'ford', isWorking: true, startIgnition: [Function] }

console.log(makeFord.constructor); //=> [Function: MakeAnotherCar]

console.log(makeAcura.constructor); //=> [Function: Object]

let x = 10; // the value of 10 is stored inside x

let y = x; // when x is copied into y, it is copied exactly as 10 into the new variable... it is indpendant now.

x = 20; // so if you change the value of x to 20...

console.log(x) // 20 is the the value of x because we changed it...

console.log(y) // 10 is the value of y because when we copied it it was 10 and it is independant.

/* • Reference types are: objects, functions, arrays.

let x = { value: 10}; // 1. since an object is not stored in the variable, but somewhere else in memory.

let y = x; // 3. So when x is copied into y, it is the ADDRESS that is copied, which will have the updated number.

x.value = 20; // 2. when you change a value in that object, the value in that address is changed,

console.log(x) // 20 Both x and y are pointed to the same address, the same object in memory.

console.log(y) // 20

let number = 10;

function increment(number) {

number++;

}

increment(number);

console.log(number); // 10... because primitives are copied by value, and when you copy number into increment it will

// be independent... which is still 10.

// However, when dealing with reference types:

let number = { value: 10 };

function increment(number) {

number.value++;

}

increment(number);

console.log(number); // 11... because the number is stored elsewhere in memory and passed by reference. In this case there is NOT

// two independent copies but one address

function superCar() {

}

const superCarCollection = superCar();

superCarCollection.truck = 'Fored Raptor'; // dot notation

superCarCollection['suv'] = 'Lamborghinini Urus'; // bracket notation

console.log(superCarCollection);

function carsClasses() {

}

const carsClassesList = carsClasses();

for (let key in carsClassesList) {

console.log(key);

} //=> entry

// middle

// luxury

Object.keys(carsClassesList).forEach(function(key) {

console.log(`car class: ${key}, car make: ${carsClassesList[key]}`);

});

// the car class is entry and the car make is Honda

// the car class is middle and the car make is Mercedes

// the car class is luxury and the car make is Rolls Royce

function classicCar(name) {

}

const classicPorsche = classicCar('911');

console.log(classicPorsche);

const sayWhat = classicPorsche.factualComparison;

console.log(sayWhat);

function Circle(radius) {

}

const circle = new Circle(10);

console.log(circle);

circle.draw();

function Circle2(radius) {

}

const circle2 = new Circle2(10);

circle2.draw();