1.
Loops
for loop
The for loop repeats a block of code a specified number of times. It is best used when you know how many times you
Example:
javascript
Copy code
for (let i = 0; i < 5; i++) {
console.log(i); // prints numbers from 0 to 4
}
forEach loop
The forEach method executes a function once for each array element. It cannot be stopped like a for loop.
Example:
javascript
Copy code
const arr = [1, 2, 3, 4];
arr.forEach(num => console.log(num)); // prints each number in the array
for..in loop
The for..in loop iterates over the properties of an object (or the index of an array).
Example:
javascript
Copy code
const person = { name: "Alice", age: 25 };
for (let key in person) {
console.log(key, person[key]); // logs "name Alice" and "age 25"
}
for..of loop
The for..of loop iterates over iterable objects like arrays, strings, etc. It retrieves values directly.
Example:
javascript
Copy code
const numbers = [1, 2, 3];
for (let num of numbers) {
console.log(num); // prints each number in the array
}
while loop
A while loop will run as long as the condition is true.
Example:
javascript
Copy code
let i = 0;
while (i < 3) {
console.log(i); // prints 0, 1, 2
i++;
}
2. Mutable and Immutable Methods in Strings and Arrays
Mutable: Changes the original array or string.
Immutable: Does not change the original, but returns a new value.
Strings (Immutable)
javascript
Copy code
let str = "hello";
let upperStr = str.toUpperCase(); // Immutable method, returns new string
console.log(str); // "hello"
console.log(upperStr); // "HELLO"
Arrays (Mutable and Immutable)
javascript
Copy code
let arr = [1, 2, 3];
// Mutable method: pop()
arr.pop(); // Removes last element, changes original array
console.log(arr); // [1, 2]
// Immutable method: concat()
let newArr = arr.concat([4, 5]); // Does not change original, returns new array
console.log(newArr); // [1, 2, 4, 5]
3. Pass by Reference and Pass by Value
Pass by Value: Primitive data types (numbers, strings, etc.) are copied when passed to a function.
Pass by Reference: Objects and arrays are passed by reference, so changes inside functions affect the original.
Example:
javascript
Copy code
let x = 10; // pass by value
function modifyValue(val) {
val = 20;
}
modifyValue(x);
console.log(x); // still 10
let obj = { key: "value" }; // pass by reference
function modifyObj(objRef) {
objRef.key = "newValue";
}
modifyObj(obj);
console.log(obj.key); // "newValue"
4. Array Methods
Basics:
pop() (Mutable): Removes the last element.
let arr = [1, 2, 3];
arr.pop(); // [1, 2]
push() (Mutable): Adds an element to the end.
arr.push(4); // [1, 2, 4]
concat() (Immutable): Combines arrays.
let newArr = arr.concat([5, 6]); // [1, 2, 4, 5, 6]
slice() (Immutable): Returns a portion of the array.
let sliced = arr.slice(1, 2); // [2]
splice() (Mutable): Adds/removes elements.
arr.splice(1, 1); // Removes element at index 1
join() (Immutable): Converts array to string.
let joined = arr.join("-"); // "1-2-4"
flat() (Immutable): Flattens nested arrays.
let nested = [1, [2, 3], 4];
let flatArr = nested.flat(); // [1, 2, 3, 4]
Finding:
find() (Immutable): Returns the first matching element.
let found = arr.find(num => num === 2); // 2
indexOf() (Immutable): Returns the index of the first occurrence.
let index = arr.indexOf(4); // 2
includes() (Immutable): Checks if the array contains a value.
let hasTwo = arr.includes(2); // true
findIndex() (Immutable): Returns the index of the first matching element.
let idx = arr.findIndex(num => num === 4); // 2
Higher Order Functions:
forEach() (Immutable): Executes a function for each element.
arr.forEach(num => console.log(num));
filter() (Immutable): Filters array elements based on a condition.
let filtered = arr.filter(num => num > 1); // [2, 4]
map() (Immutable): Transforms array elements.
let doubled = arr.map(num => num * 2); // [2, 4, 8]
reduce() (Immutable): Reduces array to a single value.
let sum = arr.reduce((acc, num) => acc + num, 0); // 7
sort() (Mutable): Sorts array elements.
arr.sort((a, b) => a - b); // [1, 2, 4]
Advanced: Array Method Chaining
let result = arr
.filter(num => num > 1)
.map(num => num * 2)
.reduce((acc, num) => acc + num, 0); // 12
5. String Methods
Mutable Methods:
Strings are immutable in JavaScript, meaning that no method can modify the original string. Methods like replace(), to
let str = "hello world";
// Immutable: returns a new string
let newStr = str.replace("world", "JavaScript");
console.log(newStr); // "hello JavaScript"
6. Object Methods and Operations
Mutable Methods:
let obj = { name: "Alice", age: 25 };
// Adding a new property (Mutable)
obj.location = "New York";
console.log(obj); // { name: "Alice", age: 25, location: "New York" }
Immutable Methods:
// Immutable method: Object.assign() creates a copy
let newObj = Object.assign({}, obj, { age: 30 });
console.log(newObj); // { name: "Alice", age: 30, location: "New York" }
7. Hoisting
Variables and functions are hoisted to the top of their scope. let and const are hoisted but not initialized.
console.log(a); // undefined (var is hoisted)
var a = 5;
console.log(b); // Error: b is not defined (let is not initialized)
let b = 10;
8. Scopes
Global Scope: Variables declared outside functions are globally accessible.
Function Scope: Variables declared inside functions are accessible only within that function.
Block Scope: Variables declared inside blocks (if, for) using let or const are block-scoped.
9. Closures
A closure is a function that has access to its own scope, the outer function's scope, and the global scope.
Example:
javascript
Copy code
function outer() {
let outerVar = "I am outer";
return function inner() {
console.log(outerVar); // Has access to outerVar
};
}
const closureFunc = outer();
closureFunc(); // "I am outer"
10. Higher Order Functions
A higher-order function is a function that takes another function as an argument or returns a function.
Example:
Copy code
function greet(name) {
return function(message) {
console.log(message + ", " + name);
};
}
const greetUser = greet("Alice");
greetUser("Hello"); // "Hello, Alice"
