DEV Community: Megan Paffrath

JavaScript: Default Parameters, Spread Operator, Rest Parameters, and Destructuring!

Megan Paffrath — Thu, 08 Aug 2024 17:46:22 +0000

Default Params

We can add a default value directly in our parameter list

function rollDie(numSides = 6) {
  return Math.floor(Math.random() * numSides) + 1;
}

Here, we need to watch out for order. Defaulted parameters should only occur at the end after any parameters that do not have defaults:

function greet(person, msg = 'Hey there', punc = '!') {
  return `${msgs}, ${person}${punc}`;
}

Spread

The Spread syntax allows an iterable such as an array to be expanded in places where zero or more arguments (for function calls) or elements (for array literals) are expected, or an object expression to be expanded in places where zero or more key-value pairs (for object literals) are expected. - MDN

We can use the spread operator on arrays:

console.log(Math.max(1, 2, 3, 4, 5, 2)); // 5
const nums = [4, 3, 53, 3, 5, 2, 4, 920, 3, 5, 2];
console.log(Math.max(...nums)); // 920

We can use the spread operator to concat arrays:

const cats = ['Fluffy', 'Zane', 'Jim'];
const dogs = ['Doggo', 'Sir Barks A Lot'];
const allPets = [...cats, ...dogs, 'Goldy'];
console.log(allPets); //['Fluffy', 'Zane', 'Jim', 'Doggo', 'Sir Barks A Lot', 'Goldy']

We can use spread to copy properties from one object to another:

const feline = {
  legs: 4,
  family: 'Felidae',
};
const canine = {
  family: 'Canine',
  furry: true,
};

const dog = { ...canine, isPet: true };
console.log(dog); // {family: 'Canine', furry: true, isPet: true}

// Note, order matters - the last property takes precidence:
const catDog = { ...feline, ...canine };
console.log(catDog); // {legs: 4, family: 'Canine', furry: true}

Spread on arrays and strings uses indexes as key values:

let newObj = { ...[2, 4, 6, 8] };
console.log(newObj); // {0: 2, 1: 4, 2: 6, 3: 8}

let anotherObj = { ...'Hello' };
console.log(anotherObj); //{0: 'H', 1: 'e', 2: 'l', 3: 'l', 4: 'o'}

A more real life example of using spread is if we wanted to add data to a form:

const dataFromForm = {
  email: 'jim@jimelm.com',
  password: '1234',
  username: 'jimelm',
};

const person = { ...dataFromForm, id: 2134, isAdmin: false };
console.log(person); // {email: 'jim@jimelm.com', password: '1234', username: 'jimelm', id: 2134, isAdmin: false}

Rest Params

Rest does the opposite of spread. It takes a bunch of parameters passed into a function and combines them into an array. Some examples include:

function sum(...nums) {
  return nums.reduce((total, el) => total + el);
}

function raceResults(gold, silver, ...everyoneElse) {
  console.log(`Gold metal goes to ${gold}`);
  console.log(`Silver metal goes to ${silver}`);
  console.log(`And thanks to: ${everyoneElse}`);
}

Destructuring

Destructuring Arrays

Here is an example of destructuring an array:

const scores = [999, 888, 777, 666, 555, 444];

const [gold, silver, bronze, ...otherScores] = scores;
console.log(gold); // 999
console.log(silver); // 888
console.log(bronze); // 777
console.log(otherScores); // [666, 555, 444]

Destructuring Objects

Here we will destructure an object:

const user = {
  email: 'marryelm@what.com',
  password: '134jsdf',
  firstName: 'Marry',
  lastName: 'Elm',
  born: 1927,
  died: 2091,
  city: 'Hayward',
  state: 'CA',
};

const { email, state, city } = user;
console.log(email); // marryelm@what.com
console.log(state); // CA
console.log(city); // Hayward

const { born: birthYear } = user;
console.log(birthYear); // 1927

We can give our variables default values as follows:

const user2 = {
  email: 'stacy@what.com',
  firstName: 'stacy',
  lastName: 'kent',
  born: 1984,
  city: 'Boise',
  state: 'ID',
};

const { city, state, died } = user2;
console.log(died); // undefined

const { city, state, died = 'N/A' } = user2;
console.log(died); // N/A

Destructuring Parameters

We can also destructure within function parameters:

const user2 = {
  email: 'stacy@what.com',
  firstName: 'stacy',
  lastName: 'kent',
  born: 1984,
  city: 'Boise',
  state: 'ID',
};

function fullName({ firstName, lastName = '???' }) {
  return `${firstName} ${lastName}`;
}

We cal also destructure in callback functions:

const movies = [
  {
    title: 'Indiana Jones',
    score: 77,
    year: 1994,
  },
  {
    title: 'Star Trek',
    score: 94,
    year: 1983,
  },
  {
    title: 'Deadpool',
    score: 79,
    year: 2001,
  },
];

let ratings = movies.map(({ title, score }) => {
  return `${title} is rated ${score}`;
});

console.log(ratings); // ['Indiana Jones is rated 77', 'Star Trek is rated 94', 'Deadpool is rated 79']

JavaScript: forEach, map, Arrow Functions, setTimeout, setInterval, filter, some, every, and reduce

Megan Paffrath — Wed, 07 Aug 2024 22:05:47 +0000

forEach Method

forEach is used to iterate over arrays. Here is a simple example:

const numbers = [1, 2, 3, 4, 5, 6, 7];

numbers.forEach(function (el) {
  if (el % 2 === 0) {
    console.log(el);
  }
});

Now let's use forEach with an array of objects:

const movies = [
  {
    title: 'Indiana Jones',
    score: 77,
  },
  {
    title: 'Star Trek',
    score: 94,
  },
  {
    title: 'Deadpool',
    score: 79,
  },
];

movies.forEach(function (movie) {
  console.log(`${movie.title} - ${movie.score}/100`);
});

Map

Map creates a new array with the results from calling a callback on every element in the array.

First, let's iterate over a basic array:

const lCase = ['jim', 'bob', 'abby'];
const uCase = lCase.map(function (t) {
  return t.toUpperCase();
});

console.log(lCase, uCase);

Now, let's iterate over an array of objects:

const movies = [
  {
    title: 'Indiana Jones',
    score: 77,
  },
  {
    title: 'Star Trek',
    score: 94,
  },
  {
    title: 'Deadpool',
    score: 79,
  },
];

const titles = movies.map(function (movie) {
  return movie.title;
});
console.log(titles);

Arrow Functions

We can write arrow functions as follows to simplify our syntax:

const square = (x) => {
  return x * x;
};

const sum = (x, y) => {
  return x + y;
};

const rollDie = () => {
  return Math.floor(Math.random() * 6) + 1;
};

console.log(square(2), sum(2, 3));
console.log(rollDie());

We can also re-visit the movie example and use an arrow function:

const movies = [
  {
    title: 'Indiana Jones',
    score: 77,
  },
  {
    title: 'Star Trek',
    score: 94,
  },
  {
    title: 'Deadpool',
    score: 79,
  },
];

const newMovies = movies.map((movie) => {
  return `${movie.title} - ${movie.score} / 10`;
});

Implicit Returns

Implicit returns are another shorthand way of writing functions, some examples include:

const rollDie = () => Math.floor(Math.random() * 6) + 1;
const isEven = (num) => num % 2 === 0;

Set Timeout

Runs the callback after x milliseconds

console.log('Apears 1st');
// takes callback, then milliseconds
setTimeout(() => {
  console.log('Apears 3rd');
}, 3000);

console.log('Apears 2nd');

Set Interval

Repeats the callback every x milliseconds

setInterval(() => {
  console.log(Math.random());
}, 2000);

If we want to eventually make the callback stop, we can do this:

const id = setInterval(() => {
  console.log(Math.random());
}, 2000);

clearInterval(id); // stops the loop

Filter Method

Filter creates a new array with the elements that return true within the callback function

const nums = [9, 8, 7, 6, 5, 4, 3, 2, 1];
const odds = nums.filter((n) => {
  return n % 2 === 1; // our callback returns true or false
  // if it returns true, n is added to the filtered array
});
// [9, 7, 5, 3, 1]

const smallNums = nums.filter((n) => n < 5); // [4, 3, 2, 1]

We can also filter objects in an array:

const movies = [
  {
    title: 'Indiana Jones',
    score: 77,
  },
  {
    title: 'Star Trek',
    score: 94,
  },
  {
    title: 'Deadpool',
    score: 79,
  },
];

const badMovies = movies.filter((movie) => {
  return movie.score < 80;
});

console.log(badMovies);

Some and Every

Some - tests if ANY of the elements in an array return true in the callback function. It returns a boolean

const firstWords = ['dog', 'jello', 'log', 'bag', 'wag', 'cupcake'];

words.some((word) => {
  return word.length > 4;
}); // true

words.some((word) => word[0] === 'Z'); // false
words.some((word) => word.includes('cake')); // true

Every - tests if ALL the elements in an array return true in the callback function. It returns a boolean

const words = ['dog', 'dig', 'log', 'bag', 'wag'];

words.every((word) => {
  return word.length === 3;
}); // true

words.every((word) => word[0] === 'd'); // false

words.every((w) => {
  return w[w.length - 1] === 'g';
}); // true

Reduce

The first (and potential only) argument in reduce is a callback function.
- This function's first argument is a value that is subject to change as we iterate through each item.
- The second argument in this function is the value from an index of the array.
The optional second argument of reduce is the value that we want the callback function's first value to start at.

const prices = [9.99, 1.5, 19.99, 49.99, 30.5];

const total = prices.reduce((total, price) => {
  return total + price;
});

const min = prices.reduce((min, price) => {
  return Math.min(min, price);
});

console.log(min);

We can do this with an array of objects too:

const movies = [
  {
    title: 'Indiana Jones',
    score: 77,
  },
  {
    title: 'Star Trek',
    score: 94,
  },
  {
    title: 'Deadpool',
    score: 79,
  },
];

let bestMovie = movies.reduce((best, movie) => {
  if (movie.score > best.score) {
    return movie;
  }
  return best;
});

console.log(bestMovie);

We can also set the initial value of the reducer:

let nums = [1, 2, 3, 4, 5];

let totalPlus100 = nums.reduce((max, num) => {
  return (max += num);
}, 100);

console.log(totalPlus100); // 115

JavaScript: Functions, Function Expressions, Objects, Methods, and this

Megan Paffrath — Wed, 07 Aug 2024 01:39:47 +0000

Simple Basic Function

Here is a simple function that takes no arguments:

function hello() {
  console.log('Hello there stranger, how are you?');
}

hello();

Here is a function that takes one argument:

function greet(person) {
  console.log(`Hi there ${person}.`);
}

greet('Megan');

We can have more than one argument as follows:

function greetFullName(fName, lName) {
  console.log(`Hi there ${fName} ${lName}.`);
}

greetFullName('Megan', 'Paffrath');

Function Expressions

Function expressions are just another way of writing functions. They still work the same way as above:

const square = function(x) {
   return x * x;
};

square(2); // 4

Higher Order Functions

These functions operate with/on other functions, perhaps they:

accept other functions as arguments
return a function

An example of a function taking another function as an argument is:

function callTwice(func) {
  func();
  func();
}

function rollDie() {
  const roll = Math.floor(Math.random() * 6) + 1;
  console.log(roll);
}

callTwice(rollDie);
// random number
// random number

An example of a function returning a function is:

function makeBetweenFunc(min, max) {
  return function (num) {
    return num >= min && num <= max;
  };
}

const isBetween = makeBetweenFunc(100, 200);
// isBetween(130); // true
// isBetween(34); // false

Methods

We can add functions as properties on objects (these are called methods).

Ex:

const myMath = {
  PI: 3.14,
  square: function (num) {
    return num * num;
  },
  // note the 2 diff ways of defining methods
  cube(num) {
    return num ** 3;
  },
};

This

'this' is mostly used WITHIN methods of objects. It is used to reference properties of the object.

const person = {
  first: 'Abby',
  last: 'Smith',
  fullName() {
    return `${this.first} ${this.last}`;
  },
};

person.fullName(); // "Abby Smith"
person.lastName = 'Elm';
person.fullName(); // "Abby Elm"

Note, outside of objects, 'this' refers to the top-level window object. To see what this contains, enter this in the console. General functions are stored in the this object too:

// defined on its own (outside of an object)
function howdy() {
  console.log('HOWDY');
}

this.howdy(); // HOWDY

Loops: For Loops, While Loops, For...Of Loops, For...In Loops

Megan Paffrath — Tue, 06 Aug 2024 19:40:43 +0000

The point of looping is to repeat some functionality.

Some types of loops include:

for loop
while loop
for...of loop
for...in loop

For Loop

To can write a simple for loop as follows:

for (let i = 1; i <= 10; i++) {
  console.log(i); // prints numbers 1-10
}

To loop over an array, we can do as follows:

const animals = ['lizard', 'fish', 'turtle'];

for (let i = 0; i < animals.length; i++) {
  console.log(i, animals[i]);
}
// 0 'lizard'
// 1 'fish'
// 2 'turtle'

We can also loop over this array in reverse:

for (let i = animals.length - 1; i >= 0; i--) {
  console.log(i, animals[i]);
}

// 2 'turtle'
// 1 'fish'
// 0 'lizard'

We can also make a loop within a loop:

for (let i = 0; i <= 2; i++) {
  for (let j = 0; j < 2; j++) {
    console.log(`i=${i}, j=${j}`);
  }
}

// i=0, j=0
// i=0, j=1
// i=1, j=0
// i=1, j=1
// i=2, j=0
// i=2, j=1

This is useful if we want to iterate over an array of arrays:

const seatingChart = [
  ['Abigale', 'Tim', 'Cynthia'],
  ['Bob', 'Carter', 'Zane', 'Tanja'],
  ['Quin', 'Xavier'],
];

// To print each name individually from seatingChart:
for (let i = 0; i < seatingChart.length; i++) {
  for (let j = 0; j < seatingChart[i].length; j++) {
    console.log(seatingChart[i][j]);
  }
}

While Loop

An example of a simple while loop is:

let num = 0;

// to print out 0 through 4:
while (num < 5) {
  console.log(num);
  num++;
}

Break keyword

The break keyword can be used to exit a while loop:

let input = prompt('Say something:');
while (true) {
  input = prompt(input);
  if (input === 'stop copying me') {
    break; // finally stops prompting user
  }
}

It can also be used to exit a for loop. Let's say we have the line:

let line = ['Abby', 'Salvia', 'Jamie', 'Carter', 'John'];

and we want to output everyone that comes before Jamie, but not Jamie:

for (let i = 0; i < line.length; i++) {
  if (line[i] === 'Jamie') break;
  console.log(line[i]);
}

For...Of Loops

If we want to print each value from an array, we can do something like:

let people = ['Agitha', 'Bruce', 'Charlie', 'Dane', 'Ernie'];
// to print each persons name:
for (let person of people) {
  console.log(person);
}

To make our seating chart example from before more legible, we can do:

const seatingChart = [
  ['Abigale', 'Tim', 'Cynthia'],
  ['Bob', 'Carter', 'Zane', 'Tanja'],
  ['Quin', 'Xavier'],
];

// To print each name individually from seatingChart:
for (let row of seatingChart) {
  for (let person of row) {
    console.log(person);
  }
}

For...In Loops

If we want to iterate through each key value pair in an object, we can do something like:

const testScores = {
  jim: 34,
  abby: 93,
  greg: 84,
  mark: 95,
  melvin: 73,
};

for (let person in testScores) {
  console.log(`${person} scored ${testScores[person]}`);
}

If we want to get the average of the testScores using For...Of, we can do as follows:

let total = 0;
let scores = Object.values(testScores);
for (let score of scores) {
  total += score;
}
let avg = total / scores.length;
console.log(avg);

Object Literals

Megan Paffrath — Tue, 06 Aug 2024 16:56:20 +0000

Objects are collections of key-value pairs (properties).

To create an object we can do as follows:

let person = {
   firstName: 'Megan',
   isOnVacation: true,
   favFoods: ['plum', 'salad', 'fritos']
}

To access values within the object we can:

console.log(person.isOnVacation); // true
console.log(person['isOnVacation']); // true

We can also make an object that contains objects:

let student = {
   name: 'Jimmy',
   exams: {
      artFinal: 'A',
      mathFinal: 88
   }
}

To access a value in the object's object, we can:

console.log(student.exams.artFinal); // 'A'

Also, we can make arrays containing objects:

let friends = [
   {
      name: 'Sorour',
      favColor: 'blue',
      metAt: 'college'
   },
   {
      name: 'Timothy',
      favColor: 'red',
      metAt: 'Starbucks'
   }
];

To access a value in the second object, we can call:

console.log(friends[1].favColor); // 'red'

To update a value in the second object, we can:

friends[1].name = 'Tim';

console.log(friends[1].name); // Tim

Array Methods: concat(), includes(), indexOf(), reverse(), slice(), splice()

Megan Paffrath — Mon, 05 Aug 2024 03:20:25 +0000

Array Methods

Let's learn a few array methods! If you want to play around to learn, please open up the console. On a mac you can press command + option + j

.concat()

If we want to combine 2 arrays we can use .concat():

const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = array1.concat(array2);

console.log(array3); // ['a', 'b', 'c', 'd', 'e', 'f']

.includes()

If we want to check if an array includes a particular value we can call .includes() which will return either true or false:

const animals = ['giraffe', 'elephant', 'dog', 'zebra'];
console.log(animals.includes('dog')); // true
console.log(animals.includes('coyotte')); // false
console.log(animals.includes('elephan')); // false
console.log(animals.includes('Elephant')); // false
console.log(animals.includes('elephant')); // true

.indexOf()

If we want to find the index of a particular value we can call .indexOf which will return an index value:

const animals = ['giraffe', 'elephant', 'dog', 'zebra'];
console.log(animals.indexOf('tiger')); // -1 (not in array)
console.log(animals.indexOf('dog')); // 2

An easy way to check if an item is in an array is to also use .indexOf(). If .indexOf() returns a -1, the item is not in the array, otherwise it is in the array.

const animals = ['giraffe', 'elephant', 'dog', 'zebra'];
if (animals.indexOf('butterfly') === -1) {
   console.log('this animal is not in the array'); // this is what we get
} else {
   console.log('this animal is in the array');
}

reverse()

If we want to reverse an array, we can call .reverse()

const animals = ['giraffe', 'elephant', 'dog', 'zebra'];
animals.reverse();
console.log(animals); // ['zebra', 'dog', 'elephant', 'giraffe']

.slice()

If we want to extract a section of an array, we can call .slice(). This method will take either 0 arguments (returns whole array), 1 argument: an index value (returns this index through the last index), 2 arguments: 2 index values (returns the first index up to - not including - the last index supplied):

const animals = ['zebra', 'dog', 'elephant', 'giraffe'];
const copyAnimals = animals.slice();
console.log(copyAnimals); // ['zebra', 'dog', 'elephant', 'giraffe']

const last3Animals = animals.slice(1);
console.log(last3Animals); // ['dog', 'elephant', 'giraffe']

const first2Animals = animals.slice(0, 2);
console.log(first2Animals); // ['zebra', 'dog']

console.log(animals); // ['zebra', 'dog', 'elephant', 'giraffe']; (remains unchanged)

.splice()

If we want to insert an item into an array we can call .splice(). With .splice() there is also an option to delete elements where we are inserting into. The first argument is the index that we want to insert into, the second argument is the number of items we want to delete, and the third argument is what we want to insert:

const animals = ['zebra', 'dog', 'elephant', 'giraffe'];
animals.splice(1, 0, 'cat'); // will insert cat at index 1
console.log(animals); // ['zebra', 'cat', 'dog', 'elephant', 'giraffe']

animals.splice(2, 2, 'whale'); // will insert whale at index 2 and delete 2 elements from ['zebra', 'cat', 'dog', 'elephant', 'giraffe']
console.log(animals); // ['zebra', 'cat', 'whale', 'giraffe']

MORE METHODS WOOOO! 🎉

Note: for a list of more array methods, check out MDN: Array

JavaScript: Arrays, Array Properties, Array Methods: push, pop, shift, unshift, Stacks, and Queues!

Megan Paffrath — Sun, 04 Aug 2024 04:36:43 +0000

Arrays

Arrays are ordered collections of values/variables that are stored sequentially. They are also considered to be objects.

I welcome you to play around with arrays in the console as you read this article. On a mac, you can press command + option + j to open console in Chrome. 🎉

// To make an empty array
let arr = [];

// To make an array of strings
let friends = ['Jim', 'Linda', 'Jerry'];

// To make an array of numbers
let ranNums = [35, 93, 2, 53];

// Arrays can also contain a mix of types
let whoKnows = ['String', 3, NaN, null];

Accessing Elements in an array

Let's say we have

let arr = [0, 1, 2, 3, 4];

as well as

let arr2 = [39, 84, 24, 94, 35];

Arrays have indices that start at 0. To access the first element in an array we would call arr[0] and to access the second we would call arr[1] and so forth. If we try to access an index that does not exist in an array, say arr[839], we will get undefined.

For example:

console.log(arr2[2]); // 24
console.log(arr2[934]); // undefined

Updating an array

If we want to update an item at a specific index, we can do something like:

arr2[0] = 99;
console.log(arr2); // [99, 84, 24, 94, 35]

Array Properties

We can check the length of an array as follows

let cats = ['Toby', 'Abigale', 'Bob'];
console.log(cats.length); // 3

Array Methods

Before we jump into array methods, a great way to think of an array is like a line of people waiting to get into a theme park. Let's say we have:

let line = ['Abby', 'Jim', 'Timmy'];

We can think of this such that Abby is first in line, then Jim, then Timmy.

If we want to add someone to the end of the line (array) we can call the .push() method:

line.push('Ethan');
console.log(line); // ['Abby', 'Jim', 'Timmy', 'Ethan']

Now, if Ethan got tied and wanted to leave the line we could remove him from the end of the line (array) by calling .pop():

line.pop();
console.log(line); // ['Abby', 'Jim', 'Timmy']

As Abby enters the theme park, we may want to remove her from the front of the line (array) by calling .shift()

line.shift();
console.log(line); // ['Jim', 'Timmy']

Jim and Timmy are waiting patiently in line, but Samuel is a total butthead and decides to cut the line (array) by calling .unshift()

line.unshift('Samuel');
console.log(line); // ['Samuel', 'Jim', 'Timmy']

Now, Ethan gets back in line with his friend Caitlyn. They can be appended to the line (array) together by calling .push()

line.push('Ethan', 'Caitlyn');
console.log(line); // ['Samuel', 'Jim', 'Timmy', 'Ethan', 'Caitlyn']

Stacks and Queues

Congratulations! Without realizing it, you learned how stacks and queues work.

A stack can be thought of like a stack of plates where you .push() and .pop() from the top (end of the array).

A queue can be thought of like a line where you .push() people onto the end of the line (array) and shift() them out of the front of the line (array).

JavaScript: String Template Literals

Megan Paffrath — Sat, 03 Aug 2024 04:34:36 +0000

String template literals give us a cleaner way to concatenate our strings and variables.

Let's say we have 5 hens and 3 roosters.

let hens = 5;
let roosters = 3;

We want to print out "We have 8 chickens, 5 of which are hens and 3 of which are roosters."

We could say:

let str = "We have " + (hens+roosters) + " chickens, " + hens + " of which are hens and " + roosters + " of which are roosters.";

// str = 'We have 8 chickens, 5 of which are hens and 3 of which are roosters.'

Or we could say

let str = `We have ${hens + roosters} chickens, ${hens} of which are hens and ${roosters} of which are roosters.`

// str =  'We have 8 chickens, 5 of which are hens and 3 of which are roosters.'

The second way of making this string is easier to both code and read!

JavaScript: Strings, String Methods, and String Properties

Megan Paffrath — Sat, 03 Aug 2024 02:45:26 +0000

Strings

Strings are primitive values in JS that contain letters and characters. Some examples of such include:

let firstName = 'Megan';
let lastName = "Paffrath";
let quotation = '"Man is asked to make of himself what he is supposed to become to fulfill his destiny" -Paul Tillich';
let sentence = "Let's code some fun stuff";

String Properties

String properties are the properties applied to a string, such as string length as shown below:

let whatUp = 'What Up!';
console.log(whatUp.length); // 8

String Methods

String methods are methods that we call on a string that perform an action. Some examples include:

let intro = " Hello there! ";
console.log(intro.toUpperCase()); // HELLO THERE! (note the space before and after)
console.log(intro.trim()); //HELLO THERE!(note the removal of spaces before and after)

String Methods with Arguments

These are methods that accept arguments, as shown bellow:

let whatUp = "What Up Tho!";
console.log(whatUp.indexOf('Up')); // 5
console.log(whatUp.indexOf('$')); // -1
console.log(whatUp.slice(5)); // Up Tho!
console.log(whatUp.slice(1,4)); // hat
console.log(whatUp.replace('Tho', 'Friend?!')); // What Up Friend?
console.log('lol'.repeat(10)); // lollollollollollollollollollol

note: these are some notes for myself from Section 15 of The Web Developer Bootcamp. To learn more, check out the course.