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 ↴
for loop → executes a block of code a number of times.
modulo operator % (remainder operator) → returns the remainder left over when one operand is divided by a second operand.
for loop repeatedly executes a block of code until a specified condition evaluates to false.
The loop runs a block of code a set number of times, defined by an initialization, a condition, and an increment.
for (let x = 0; x < 4; x++) {
console.log(x);
}
Loop variable x is initialized to 0
Condition x < 4 is checked before each iteration.
The loop will continue to run as long as x is less than 4
The loop repeatedly executes a block of code 4 times, from 0 to 3
For each iteration of the loop, the current value of x is printed to the console.
After each iteration, x is incremented by 1 x++
When x reaches 4 the condition evaluates to false, terminating the loop.
0
1
2
3 → printed to console
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 arr2 = ["Hello", "World"]; → array
const [a, b] = arr2;
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 the 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
Loop through each element in the array.
for (let x = 0; x < arr.length; x++) {}
Using the modulo operator check if the current element arr[x] is even.
if (arr[x] % 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 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 oddCount = 0;
let evenCount = 0;
for (let x = 0; x < arr.length; x++) {
if (arr[x] % 2 === 0) {
evenCount++;
} else {
oddCount++;
}
}
return [oddCount, evenCount];
}
call function
const [odd, even] = countOddEven(array1);
odd returns → 5
even returns → 8
Alternative using a ternary operator.
Count odd & even numbers in an array.
const array2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16];
function countOddEven2(arr) {
let oddCount = 0;
let evenCount = 0;
for (let x = 0; x < arr.length; x++) {
arr[x] % 2 === 0 ? evenCount++ : oddCount++
}
return [oddCount, evenCount];
}
call function
const [odd, even] = countOddEven2(array2);
odd returns → 5
even returns → 8