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
Count odd and even numbers in an array using ↴
forEach() method → calls a function for each element in an array, executing a provided function once for each array element.
modulo operator % (remainder operator) → returns the remainder left over when one operand is divided by a second operand.
forEach() method calls a function for each element in an array, executing a provided function once for each array element.
The method does not return a new array, it always returns undefined
const arr2 = [2, 4, 6, 8];
arr2.forEach((element, index, array) => {
array[index] = element * 2;
});
console.log(arr2); returns ↴
[4, 8, 12, 16] → value of each element is doubled
const arr3 = [2, 4, 6, 8];
arr3.forEach((element, index) => {
console.log(index, element)
}); returns ↴
0 2
1 4
2 6
3 8 → index and element printed to console
Use forEach() when an action is needed to be performed on each element,
not when a new array needs to be generated from the current one.
Modulo operator % (remainder operator) returns the remainder left over when one number is divided by a second number.
10 % 2 → remainder 0
10 % 3 → remainder 1
10 % 4 → remainder 2
10 % 5 → remainder 0
The modulo operator can be used to check whether a number is odd or even.
If a number is divisible by 2 (with no remainder) then it must be an even number.
If a number is not divisible by 2 (with a remainder) then it must be an odd number.
4 % 2 === 0; statement is true, remainder is zero, so 4 is an even number.
5 % 2 === 0; statement is false, remainder is not zero, so 5 is an odd number.
function checkNumber(num) {
if (num % 2 === 0) { if num divisible by 2
console.log(num + " is even"); if true
} else {
console.log(num + " is odd"); if false
}
}
checkNumber(2); → 2 is even
checkNumber(3); → 3 is odd
checkNumber(4); → 4 is even
checkNumber(5); → 5 is odd
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 arr4 = ["Hello", "World"]; → array
const [a, b] = arr4;
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 to count odd and even numbers.
const array1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16]; → user input
Define a function countOddEven to count odd and even numbers in an array.
function countOddEven(arr) {}
The function takes an array of numbers as input arr and returns the count of odd and even numbers found.
Initialize counters for odd and even numbers.
let oddCount = 0 oddCount counter for odd numbers
let evenCount = 0 evenCount counter for even numbers
forEach() method loops through the array, executing a callback function once for each array element.
arr.forEach(callbackFn) ↴
callback function ↴
(num) => {
if (num % 2 === 0) {
evenCount++
} else {
oddCount++
}
}
num is the current element being processed in the array.
Using the modulo operator, check if the number is even.
If the remainder is zero, it is even; otherwise, it is odd.
if (num % 2 === 0) {}
If true, increment even counter by 1
evenCount++
else if false, increment odd counter by 1
oddCount++
Return an array containing the counts of odd and even numbers.
return [oddCount, evenCount]
Use destructuring to assign the returned values directly to the odd and even variables, (can be any meaningful names).
Call the function and destructure the returned values.
const [odd, even] = countOddEven(array1)
odd → 5 odd numbers found
even → 8 even numbers found
Call the function with ↴
countOddEven(array1);
Count odd & even numbers in an array.
const array1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16];
function countOddEven(arr) {
let evenCount = 0;
let oddCount = 0;
arr.forEach((num) => {
if (num % 2 === 0) {
evenCount++;
} else {
oddCount++;
}
});
return [oddCount, evenCount];
}
call function
const [odd, even] = countOddEven(array1);
odd returns → 5
even returns → 8