1
2
3
4
5
6
7
8
9
10
11
12
13
14

// A list of four courses, in order
const courses = ['HTML', 'CSS', 'Tailwind', 'JavaScript'];

// How many items are in the list?
console.log(courses.length);

// The first item is at position 0
console.log(courses[0]);

// The last item: length - 1, the older way
console.log(courses[courses.length - 1]);

// The last item: at(-1), the clearer way
console.log(courses.at(-1));

1
2
3
4
5
6
7
8
9
10
11
12

// A cart with one item
const cart = ['rice'];

// Add to the end, then to the front
cart.push('beans');
cart.unshift('oil');
console.log(cart);

// Remove from the end, keeping hold of what was removed
const removed = cart.pop();
console.log(removed);
console.log(cart);

1
2
3
4
5
6
7
8

// Three scores in no particular order
const scores = [30, 100, 25];

// Sort them as numbers, smallest first
scores.sort((a, b) => a - b);

// Show the sorted list
console.log(scores);

➜ webbo3 node app.js
[ 100, 25, 30 ]

1
2
3
4
5
6
7
8
9
10
11
12

// A class register
const register = ['Chidinma', 'Musa', 'Tunde'];

// A new student joins
register.push('Amaka');

// Put the names in alphabetical order (text sorts correctly as text)
register.sort();

// Report the class
console.log(`${register.length} students`);
console.log(`First: ${register[0]}, last: ${register.at(-1)}`);

➜ webbo3 node app.js
[ 'suya', 'plantain', 'puff-puff' ]
3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// One student record, with an array and an object inside it
const student = {
  name: 'Chidinma Okafor',
  age: 22,
  enrolled: true,
  scores: [72, 65, 88],
  contact: { email: '[email protected]', city: 'Lagos' }
};

// A simple property
console.log(student.name);

// Into the nested object, then its city
console.log(student.contact.city);

// Into the nested array, then position 2
console.log(student.scores[2]);

// A property that does not exist
console.log(student.nickname);

1
2
3
4
5

// This record has no contact section at all
const student = { name: 'Musa' };

// Try to read the city inside the missing contact
console.log(student.contact.city);

1
2
3
4
5
6
7
8

// The same record with no contact section
const student = { name: 'Musa' };

// Read safely: stop at the missing part instead of crashing
console.log(student.contact?.city);

// Read safely AND supply a fallback for the missing value
console.log(student.contact?.city ?? 'Unknown');

1
2
3
4
5
6
7

// Two records: one complete, one with a missing section
const ada = { name: 'Ada', contact: { city: 'Abuja' } };
const bayo = { name: 'Bayo' };

// The same safe line works for both
console.log(`${ada.name} lives in ${ada.contact?.city ?? 'an unknown city'}`);
console.log(`${bayo.name} lives in ${bayo.contact?.city ?? 'an unknown city'}`);

➜ webbo3 node app.js
Ibadan
No phone saved

1
2
3
4
5
6
7
8
9
10
11
12
13

// Four students: an array of objects with the same properties
const students = [
  { name: 'Chidinma', score: 88, city: 'Lagos', paid: true },
  { name: 'Musa', score: 54, city: 'Kano', paid: false },
  { name: 'Tunde', score: 71, city: 'Lagos', paid: true },
  { name: 'Amaka', score: 39, city: 'Enugu', paid: true }
];

// How many records?
console.log(students.length, 'records');

// Show them as a table, like a spreadsheet
console.table(students);

1
2
3
4
5
6
7
8
9
10

// Two students
const students = [
  { name: 'Chidinma', score: 88 },
  { name: 'Musa', score: 54 }
];

// Run the block once for each student
for (const student of students) {
  console.log(`${student.name} scored ${student.score}`);
}

1
2
3
4
5
6
7
8
9
10

// The same two students
const students = [
  { name: 'Chidinma', score: 88 },
  { name: 'Musa', score: 54 }
];

// For each student, run this function with the student and its position
students.forEach((student, index) => {
  console.log(`${index + 1}. ${student.name} scored ${student.score}`);
});

➜ webbo3 node app.js
Welcome to Lagos
Welcome to Kano
Welcome to Enugu

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// Three student records
const students = [
  { name: 'Chidinma', score: 88 },
  { name: 'Musa', score: 54 },
  { name: 'Amaka', score: 39 }
];

// Turn each record into just its name
const names = students.map((student) => student.name);

// Turn each record into a sentence
const lines = students.map((student) => `${student.name} scored ${student.score}`);

// Show both new arrays, then check the original is still there
console.log(names);
console.log(lines);
console.log(students.length);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Day 2's grading function, unchanged
function gradeFor(score) {
  if (score >= 70) return 'A';
  if (score >= 60) return 'B';
  if (score >= 50) return 'C';
  return 'F';
}

// The class
const students = [
  { name: 'Chidinma', score: 88 },
  { name: 'Musa', score: 54 },
  { name: 'Amaka', score: 39 }
];

// Grade every student by calling gradeFor inside map
const grades = students.map((student) => `${student.name}: ${gradeFor(student.score)}`);

console.log(grades);

1
2
3
4
5
6
7
8

// Two students
const students = [{ name: 'Chidinma' }, { name: 'Musa' }];

// Braces and no return: the callback gives back nothing
console.log(students.map((student) => { student.name; }));

// No braces: the value is returned automatically
console.log(students.map((student) => student.name));

➜ webbo3 node app.js
[ 1075, 2687.5, 430 ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// The class
const students = [
  { name: 'Chidinma', score: 88, paid: true },
  { name: 'Musa', score: 54, paid: false },
  { name: 'Tunde', score: 71, paid: true },
  { name: 'Amaka', score: 39, paid: true }
];

// Keep only the students who scored 50 or more
const passing = students.filter((student) => student.score >= 50);

// Keep only the students who have not paid
const unpaid = students.filter((student) => !student.paid);

console.log(passing.length);
console.log(unpaid);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

// The class
const students = [
  { name: 'Chidinma', score: 88, paid: true },
  { name: 'Musa', score: 54, paid: false },
  { name: 'Tunde', score: 71, paid: true },
  { name: 'Amaka', score: 39, paid: true }
];

// Find the one student called Tunde
const tunde = students.find((student) => student.name === 'Tunde');

// Look for someone who is not in the class
const zainab = students.find((student) => student.name === 'Zainab');

console.log(tunde);
console.log(zainab);

1
2
3
4
5
6
7
8
9
10
11
12
13

// The class
const students = [
  { name: 'Chidinma', score: 88, paid: true },
  { name: 'Musa', score: 54, paid: false },
  { name: 'Tunde', score: 71, paid: true },
  { name: 'Amaka', score: 39, paid: true }
];

// Did at least one student fail?
console.log(students.some((student) => student.score < 50));

// Did every student pay?
console.log(students.every((student) => student.paid));

➜ webbo3 node app.js
undefined
Tunde

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// The class
const students = [
  { name: 'Chidinma', score: 88, paid: true },
  { name: 'Musa', score: 54, paid: false },
  { name: 'Tunde', score: 71, paid: true },
  { name: 'Amaka', score: 39, paid: true }
];

// Everyone who passed AND paid
const cleared = students.filter((student) => student.score >= 50 && student.paid);

// Report
console.log(`${cleared.length} students are cleared`);
console.log(`Anyone owing fees? ${students.some((student) => !student.paid)}`);

➜ webbo3 node app.js
[ 1500, 800 ]
true

1
2
3
4
5
6
7

// Three prices in a cart
const prices = [1500, 2000, 750];

// Start at 0, and add each price to the running total
const total = prices.reduce((runningTotal, price) => runningTotal + price, 0);

console.log(total);

1
2
3
4
5

// An empty cart
const prices = [];

// No starting value
console.log(prices.reduce((runningTotal, price) => runningTotal + price));

1
2
3
4
5

// The same empty cart
const prices = [];

// With a starting value of 0
console.log(prices.reduce((runningTotal, price) => runningTotal + price, 0));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Students and their cities
const students = [
  { name: 'Chidinma', city: 'Lagos' },
  { name: 'Musa', city: 'Kano' },
  { name: 'Tunde', city: 'Lagos' }
];

// Start with an empty object and add each student to their city's list
const byCity = students.reduce((groups, student) => {
  // Make an empty list for this city the first time we see it
  groups[student.city] = groups[student.city] ?? [];
  // Add the student's name to their city's list
  groups[student.city].push(student.name);
  // Hand the object on to the next student
  return groups;
}, {});

console.log(byCity);

➜ webbo3 node app.js
125

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// The class
const students = [
  { name: 'Chidinma', score: 88, paid: true },
  { name: 'Musa', score: 54, paid: false },
  { name: 'Tunde', score: 71, paid: true },
  { name: 'Amaka', score: 39, paid: true }
];

// Paid students, who passed, as "name: score" lines
const report = students
  .filter((student) => student.paid)
  .filter((student) => student.score >= 50)
  .map((student) => `${student.name}: ${student.score}`);

console.log(report);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

// The class
const students = [
  { name: 'Chidinma', score: 88, paid: true },
  { name: 'Musa', score: 54, paid: false },
  { name: 'Tunde', score: 71, paid: true },
  { name: 'Amaka', score: 39, paid: true }
];

// The students who passed
const passing = students.filter((student) => student.score >= 50);

// Add up their scores, then divide by how many there are
const total = passing.reduce((sum, student) => sum + student.score, 0);
const average = total / passing.length;

// toFixed(1) rounds to one decimal place and gives back text
console.log(`Average of the ${passing.length} who passed: ${average.toFixed(1)}`);

➜ webbo3 node app.js
[ 'Chidinma', 'Tunde' ]

1
2
3
4
5
6
7
8
9
10

// A student record
const student = { name: 'Chidinma', score: 88, city: 'Lagos' };

// Take name and score out into variables of the same names
const { name, score } = student;
console.log(name, score);

// Take city out, and give nickname a default because it is missing
const { city, nickname = 'none' } = student;
console.log(city, nickname);

1
2
3
4
5
6
7

// Medals in finishing order
const medals = ['gold', 'silver', 'bronze'];

// Take the first two out by position
const [first, second] = medals;

console.log(first, second);

1
2
3
4
5
6
7
8
9
10
11
12

// The original record
const base = { name: 'Chidinma', score: 88 };

// Copy it, then change score on the copy
const updated = { ...base, score: 91 };

// Copy it, then add a new property on the copy
const withGrade = { ...base, grade: 'A' };

console.log(base);
console.log(updated);
console.log(withGrade);

➜ webbo3 node app.js
[ 72, 65, 99 ]

1
2
3
4
5
6
7
8
9
10

// A student with a new score to record
const student = { name: 'Tunde', score: 71, city: 'Lagos' };

// Make an updated copy with the new score
const updated = { ...student, score: 76 };

// Unpack what we want to report
const { name, score } = updated;

console.log(`${name}'s new score is ${score}. Old record still says ${student.score}.`);

➜ webbo3 node app.js
Headphones 12000 15000

1
2
3
4
5
6
7
8
9
10
11
12

// Five orders from a small online shop
const orders = [
  { id: 1, customer: 'Chidinma', city: 'Lagos', amount: 12500, status: 'paid' },
  { id: 2, customer: 'Musa', city: 'Kano', amount: 3200, status: 'pending' },
  { id: 3, customer: 'Tunde', city: 'Lagos', amount: 45000, status: 'paid' },
  { id: 4, customer: 'Amaka', city: 'Enugu', amount: 8700, status: 'paid' },
  { id: 5, customer: 'Chidinma', city: 'Lagos', amount: 2100, status: 'failed' }
];

// Keep the Lagos orders, then count them
const lagosOrders = orders.filter((order) => order.city === 'Lagos');
console.log(lagosOrders.length);

1
2
3
4
5
6
7
8
9
10
11

// Five orders from a small online shop
const orders = [
  { id: 1, customer: 'Chidinma', city: 'Lagos', amount: 12500, status: 'paid' },
  { id: 2, customer: 'Musa', city: 'Kano', amount: 3200, status: 'pending' },
  { id: 3, customer: 'Tunde', city: 'Lagos', amount: 45000, status: 'paid' },
  { id: 4, customer: 'Amaka', city: 'Enugu', amount: 8700, status: 'paid' },
  { id: 5, customer: 'Chidinma', city: 'Lagos', amount: 2100, status: 'failed' }
];

// Ask whether at least one order has the status failed
console.log(orders.some((order) => order.status === 'failed'));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// Five orders from a small online shop
const orders = [
  { id: 1, customer: 'Chidinma', city: 'Lagos', amount: 12500, status: 'paid' },
  { id: 2, customer: 'Musa', city: 'Kano', amount: 3200, status: 'pending' },
  { id: 3, customer: 'Tunde', city: 'Lagos', amount: 45000, status: 'paid' },
  { id: 4, customer: 'Amaka', city: 'Enugu', amount: 8700, status: 'paid' },
  { id: 5, customer: 'Chidinma', city: 'Lagos', amount: 2100, status: 'failed' }
];

// Only the paid orders, then add up their amounts
const received = orders
  .filter((order) => order.status === 'paid')
  .reduce((total, order) => total + order.amount, 0);

console.log(`Received: N${received}`);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// Five orders from a small online shop
const orders = [
  { id: 1, customer: 'Chidinma', city: 'Lagos', amount: 12500, status: 'paid' },
  { id: 2, customer: 'Musa', city: 'Kano', amount: 3200, status: 'pending' },
  { id: 3, customer: 'Tunde', city: 'Lagos', amount: 45000, status: 'paid' },
  { id: 4, customer: 'Amaka', city: 'Enugu', amount: 8700, status: 'paid' },
  { id: 5, customer: 'Chidinma', city: 'Lagos', amount: 2100, status: 'failed' }
];

// Group the paid amounts by city into one object
const perCity = orders
  .filter((order) => order.status === 'paid')
  .reduce((totals, order) => {
    // Start this city at 0 the first time we see it
    totals[order.city] = (totals[order.city] ?? 0) + order.amount;
    return totals;
  }, {});

console.log(perCity);

➜ webbo3 node app.js
[ 'Chidinma: A', 'Musa: C', 'Tunde: A', 'Amaka: F' ]
3 of 4 passed. Class average: 63