Objects and Arrays form the basis of pretty much all data structures in JavaScript and allow us to represent the state of the world to be manipulated. This exercise is all about how to represent objects in the real world in an 'IT' way. We will be offering different ways of storing regular objects and for each we would like you to think about the following questions:

- What are the advantages and disadvantages of having it represented in each way?

- Do you think there is another way of representing the object? If so, what is it and what do you see as the advantage of using that way?

Every real world scenario has its own `.js` file in this folder, go through them all.

Next to thinking about each representation, also have a think about the following:

- In all of the examples, you will see that objects and arrays are mostly defined using a `const` statement rather than a `let` even if we change the value of the object or array, why do you think this is the case?

const school1 = {

students: [

{ name: "Rob", class: 1 },

{ name: "Fede", class: 2 },

],

teachers: [{ name: "Stas", class: 1 }],

const school2 = {

classes: [

[

{ name: "Rob", role: "student" },

{ name: "Stas", role: "teacher" },

],

[{ name: "Fede", role: "student" }],

],

const simpleTrafficLight = {

state: "red",

const currentTrafficLightState1 = simpleTrafficLight.state;

const trafficLightWithStates = {

possibleStates: ["green", "orange", "red"],

currentStateIndex: 0,

const currentTrafficLightState2 =

trafficLightWithStates.possibleStates[

trafficLightWithStates.currentStateIndex

];

Let's have a deeper look at the working of traffic lights this week so that we can practice logic and loops. In the previous week we went into some different ways of representing a traffic light, now let's make the traffic light work. In `traffic-light-1.js` and `traffic-light-2.js` you will find the same requirements but with different ways of representing the traffic light. Have a look through the files and solve them.

- Which way of representing the traffic light did you find better? Why?

- What happens if you change the loop to a `do-while` loop instead of a `while` loop? Why?

- We could have also used a `for` loop to make the traffic light do 2 full rotations. Do you think that would be better? Why or why not?

const trafficLight = {

state: "green",

let rotations = 0;

while (rotations < 2) {

const currentTrafficLightState = trafficLight.state;

console.log("The traffic light is on", currentTrafficLightState);

// TODO

// if the color is green, turn it orange

// if the color is orange, turn it red

// if the color is red, add 1 to rotations and turn it green

const trafficLight = {

possibleStates: ["green", "orange", "red"],

currentStateIndex: 0,

let rotations = 0;

while (rotations < 2) {

const currentTrafficLightState =

trafficLight.possibleStates[trafficLight.currentStateIndex];

console.log("The traffic light is on", currentTrafficLightState);

// TODO

// if the color is green, turn it orange

// if the color is orange, turn it red

// if the color is red, add 1 to rotations and turn it green

In the previous week we continued with our traffic light. Now that we also know what a function is we have one last look at the workings of a traffic light in a different way. Take a look at the `traffic-light.js` file and implement the same requirements as last week again, but then with another different way of organising.

- This time the loop was changed to a for loop that will run the code 6 times. Why was that needed?

- Why was the trafficLight added to the `main` function and not left at the top of the file?

- What do you think is the advantage of having the `getCurrentTrafficLightState` and `getNextStateIndex` functions?

function getCurrentTrafficLightState(trafficLight) {

// TODO

// Should return `green`, `orange` or `red` depending on the state of the given parameter

function getNextStateIndex(trafficLight) {

// TODO

// if the color is green, turn it orange

// if the color is orange, turn it red

// if the color is red, turn it green

function main() {

const trafficLight = {

possibleStates: ["green", "orange", "red"],

currentStateIndex: 0,

};

for (let i = 0; i < 6; i++) {

const currentTrafficLightState = getCurrentTrafficLightState(trafficLight);

console.log("The traffic light is on", currentTrafficLightState);

trafficLight.currentStateIndex = getNextStateIndex(trafficLight);

}

Let's do some experiments! One thing computers are great at is doing the same thing over and over and over again, so let's use that to see how random the random function in JavaScript is. In the `index.js` there is an explanation of what to implement. In essence we want to simulate the rolling of a die a lot of times and then track how many times a certain value was rolled.

- The `valueCounts` is implemented as an array. Do you think there is another way to store this? Why do you think the decision was made to go with an array?

- What do you think about the code division? Would you add another function or maybe remove one? Why?

function runExperiment(sampleSize) {

const valueCounts = [0, 0, 0, 0, 0, 0];

// TODO

// Write a for loop that iterates `sampleSize` times (sampleSize is a number).

// In each loop iteration:

//

// 1. Generate a random integer between 1 and 6 (as if throwing a six-sided die).

// 2. Add `1` to the element of the `valueCount` that corresponds to the random

// value from the previous step. Use the first element of `valueCounts`

// for keeping a count how many times the value 1 is thrown, the second

// element for value 2, etc.

const results = [];

// TODO

// Write a for..of loop for the `valueCounts` array created in the previous

// loop. In each loop iteration:

// 1. For each possible value of the die (1-6), compute the percentage of how

// many times that value was thrown. Remember that the first value of

// `valueCounts` represent the die value of 1, etc.

// 2. Convert the computed percentage to a number string with a precision of

// two decimals, e.g. '14.60'.

// 3. Then push that string onto the `results` array.

return results;

function main() {

const sampleSizes = [100, 1000, 1000000];

// TODO

// Write a for..of loop that calls the `runExperiment()` function for each

// value of the `sampleSizes` array.

// Log the results of each experiment as well as the experiment size to the

// console.

// The expected output could look like this:

//

// [ '26.00', '17.00', '10.00', '19.00', '16.00', '12.00' ] 100

// [ '14.60', '17.10', '19.30', '15.50', '16.70', '16.80' ] 1000

// [ '16.71', '16.68', '16.69', '16.66', '16.67', '16.59' ] 1000000

This week is all about combining everything we know and learning how to solve problems. To help with that, we're going to do a very difficult exercise with a lot of moving parts. As it is a prep exercise, it is something you can do together to get to the solution! Have a look at the `index.js` file for the instructions.

- Why do you think the `onSuccess` and `onFail` callback functions were used? What is the advantage of that?

- Did you create extra functions? Why or why not?

- How would you test this code?

const bankAccount = {

// The currentBalance is how much money you have in your bankAccount.

currentBalance: 250,

// The transactions are a list of changes so that you can keep track.

transactions: [

/**

{

prevAmount: 350,

newAmount: 250,

reason: "Donation",

},

],

const donateMoney = (amount, onSuccess, onFail) => {};

const payRent = (amount, onSuccess, onFail) => {};

const onSuccess = () => {

console.log("Payment successful! Thank you!");

const onFail = () => {

console.log("You do not have enough money to make this payment.");

donateMoney(100, onSuccess, onFail);

payRent(100, onSuccess, onFail);

donateMoney(100, onSuccess, onFail);