Arrays are used to store multiple values in a single variable.
Each value is called an element, and each element has a numeric position in the array, known as its index.
Arrays are zero-indexed, meaning the first element is at index 0, the second at index 1, and so on.
Arrays can contain any data type, including numbers, strings, and objects.
const arr1 = [2, 4, 6]; array
arr1[0]; element at index 0 → 2
arr1[1]; element at index 1 → 4
arr1[2]; element at index 2 → 6
arr1[3]; element at index 3 → undefined index not found
Numbers are used to represent both integer and floating-point values.
Numbers are most commonly expressed in literal forms like 255 or 3.14159 ↴
let num1 = 5; → number
let num2 = 2.5; → number
let num3 = num1 + num2;
console.log(num3); returns ↴
7.5 → number
Find the maximum difference between two numbers in an array using ↴
reduce() method → executes a reducer function, resulting in a single output value.
Math.max() static method → returns the largest of the numbers given as input parameters, or -Infinity if there are no parameters.
Math.min() static method → returns the smallest of the numbers given as input parameters, or Infinity if there are no parameters.
reduce() method iterates over each element in an array, and each iteration returns a single value, which is the accumulator.
When the iteration is finished, the accumulator value will be returned from the method.
It takes two parameters: a callback function and an optional initial value ↴
callback function first parameter.
initialValue second parameter. The accumulator is initialized to the first element of the array if no initial value is provided.
The callback function takes four parameters ↴
accumulator The value resulting from the previous call to callback function - required.
currentValue The value of the current element - required.
currentIndex Index position of currentValue in the array - optional.
Array The array reduce() was called upon - optional.
syntax
array.reduce(callback, initialValue); ↴
array.reduce((accumulator, currentValue, currentIndex, Array), initialValue)
Example 1 | Find the sum of the array ↴
const arr2 = [1, 2, 3, 4, 5, 6];
arr2.reduce((acc, cur) => acc + cur, 0); Initial value → 0
returns ↴
21
During each iteration, the current value cur will be added to the accumulator acc ↴
acc + cur
Iteration ↴
0 acc Initial value → 0
1 acc 0 → 0 + 1 = 1 → 1
2 acc 1 → 1 + 2 = 3 → 3
3 acc 3 → 3 + 3 = 6 → 6
4 acc 6 → 6 + 4 = 10 → 10
5 acc 10 → 10 + 5 = 15 → 15
6 acc 15 → 15 + 6 = 21 → 21
The return value becomes the value of the accumulator parameter acc on the next invocation of the callback function.
For the last invocation, the return value becomes the return value of reduce()
When the iteration is finished, the accumulator value will be returned ↴
21 → sum of the array
Example 2 | Find even numbers ↴
const arr3 = [11, 12, 13, 14, 15, 16, 17];
const evenNumbers = arr3.reduce((acc, cur) => {
return cur % 2 === 0 ? [...acc, cur] : acc;
}, []); Initial value → []
console.log(evenNumbers); returns ↴
[12, 14, 16]
During each iteration, the ternary operator evaluates the condition cur % 2 === 0
If current element cur is divisible by 2, it will be added to the accumulator array, acc
[...acc, cur] ↴
cur % 2 === 0 ? [...acc, cur] : acc
If current element cur not divisible by 2, the accumulator acc will be returned as is.
Iteration ↴
0 acc 11 → [] Initial value is an empty array
1 acc 11 → []
2 acc 12 → [12] 12 added to acc array
3 acc 13 → [12]
4 acc 14 → [12, 14] 14 added to acc array
5 acc 15 → [12, 14]
6 acc 16 → [12, 14, 16] 16 added to acc array
7 acc 17 → [12, 14, 16]
The return value becomes the value of the accumulator parameter acc on the next invocation of the callback function.
For the last invocation, the return value becomes the return value of reduce()
When the iteration is finished, the accumulator value will be returned ↴
[12, 14, 16] → even numbers
spread syntax ... The spread operator allows an iterable (like an array) to be expanded in places where zero or more arguments are expected.
For example, it allows two or more arrays to be merged into one array.
const arr4 = [1, 2, 3, 4, 5];
const arr5 = [4, 5, 6, 7, 8];
const arr6 = [...arr4, ...arr5];
console.log(arr6); returns ↴
[1, 2, 3, 4, 5, 4, 5, 6, 7, 8]
The spread operator is useful when working with functions that do not accept an array as a single argument.
Math.max() static method returns the largest of the numbers given as input parameters, or -Infinity if there are no parameters.
Directly pass numerical values as arguments.
Math.max(4, 2, 6, 5, 3); returns ↴
6
Use the spread syntax to pass an array of numbers.
const nums1 = [4, 2, 6, 5, 3];
Math.max(...nums1); returns ↴
6
Math.min() static method returns the smallest of the numbers given as input parameters, or Infinity if there are no parameters.
Directly pass numerical values as arguments.
Math.min(4, 2, 6, 5, 3); returns ↴
2
Use the spread syntax to pass an array of numbers.
const nums2 = [4, 2, 6, 5, 3];
Math.min(...nums2); returns ↴
2
Destructuring
The destructuring syntax is a JavaScript syntax that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.
const arr7 = ["Hello", "World"]; → array
const [a, b] = arr7;
console.log(a); returns ↴
"Hello" → first element in array
console.log(b); returns ↴
"World" → second element in array
Array destructuring assigns the first and second elements of the array directly to a and b, respectively. This eliminates the need for additional indexing, making the code cleaner and more intuitive.
Initialize a variable to hold the array find the maximum difference between two numbers.
const array1 = [4, 8, 6, 2, 5, 7, 9, 3]; → user input
Define a function maxDifference to find the maximum difference between two numbers.
function maxDifference(arr) {}
The function takes an array as input arr and returns the maximum number between two numbers found in the array.
If the array has less than two elements, return 0 and end execution of function.
if (arr.length < 2) return 0
If the array has two or more elements, use the reduce() method to find the maximum and minimum values in the array.
return arr.reduce()
reduce() method iterates over the array of numbers and returns a single object with the accumulated counts.
reduce(callbackFn, initialValue) ↴
reduce((acc, num) => (), { max: arr[0], min: arr[0] })
acc is the accumulator
num is the current element
{ max: arr[0], min: arr[0] } initial values for the counts → first element of the array
max and min are properties of the accumulator object that store the current maximum and minimum values found in the array as it is being processed.
Using destructuring they are initialized to the first element of the array and are updated with each iteration of the reduce method.
callback function ↴
const { max, min } = arr.reduce()
(acc, num) => {}
return { ... }
Update the maximum value max if the current number is greater.
max: Math.max(acc.max, num),
Update the minimum value min if the current number is smaller.
min: Math.min(acc.min, num)
initial value ↴
{ max: arr[0], min: arr[0] }
max → arr[0] first element of array
min → arr[0] first element of array
Return the difference between the maximum and minimum values
return max - min
Call the function with ↴
maxDifference(array1);
Find the maximum difference between two numbers in an array.
const array1 = [4, 8, 6, 2, 5, 7, 9, 3];
function maxDifference(arr) {
if (arr.length < 2) return 0;
const { max, min } = arr.reduce(
(acc, num) => {
return {
max: Math.max(acc.max, num),
min: Math.min(acc.min, num)
};
},
{ max: arr[0], min: arr[0] }
);
return max - min;
}
call function
maxDifference(array1); returns ↴
7
9 - 2 = 7 ✔