DEV Community: Jenil

4 JavaScript Array Methods Every Developer Should Master (Part 2)

Jenil — Sat, 12 Oct 2024 21:02:49 +0000

JavaScript offers a powerful set of built-in array methods that make working with data much easier.

In this post, we’ll explore four commonly used array methods: concat(), reverse(), fill(), and join().

Each of these methods is a valuable tool for manipulating arrays in different ways. Let’s dive in!

If you haven't read our previous post yet, be sure to check out Part 1 for more useful array techniques! This will give you a complete overview of even more powerful array methods.

1. `concat()`

The concat() method allows you to merge multiple arrays or values into a new array. It does not modify the original array but returns a new one with the combined contents.

Syntax:

arr.concat(value1, value2, ...);

value1, value2, ... – Can be arrays or values to merge.

If the argument is an array, all elements from that array are copied; otherwise, the argument itself is copied.

Example:

const arr = [1, 2];

// Merging arr with another array [3, 4]
const arr1 = arr.concat([3, 4]);
console.log(arr1);  // Output: [1, 2, 3, 4]

// Merging arr with two arrays [3, 4] and [5, 6]
const arr2 = arr.concat([3, 4], [5, 6]);
console.log(arr2);  // Output: [1, 2, 3, 4, 5, 6]

// Merging arr with two arrays and additional values 5 and 6
const arr3 = arr.concat([3, 4], 5, 6);
console.log(arr3);  // Output: [1, 2, 3, 4, 5, 6]

2. `reverse()`

The reverse() method reverses the order of elements in the original array. Unlike other array methods, reverse() modifies the original array in-place and also returns it.

Syntax:

arr.reverse();

Example:

const arr = [1, 2, 3, 4, 5];

// Reverses the array in place and returns the reversed array
const reversedArr = arr.reverse();
console.log(reversedArr);  // Output: [5, 4, 3, 2, 1]

// Original array is also reversed
console.log(arr);  // Output: [5, 4, 3, 2, 1]

3. `fill()`

The fill() method fills all elements in an array with a specified value. It’s a mutator method, meaning it modifies the original array and returns the updated version.

Syntax:

arr.fill(value, start, end)

value – The value to fill the array with.
start (optional) – The starting index (default is 0).
end (optional) – The ending index (default is arr.length).

Important: The end index is not included—it acts as an exclusive boundary. This means that the filling will stop right before the element at the end index.

Example:

const nums1 = [15, 27, 19, 2, 1];
const nums2 = [25, 28, 34, 49];
const nums3 = [8, 9, 3, 7];

// Fill all elements with 5
const newNums1 = nums1.fill(5);
console.log(nums1);  // Output: [5, 5, 5, 5, 5]
console.log(newNums1);  // Output: [5, 5, 5, 5, 5]

// Fill elements from index 1 to 3 with 25
nums2.fill(25, 1, 3);
console.log(nums2);  // Output: [25, 25, 25, 49]

// Fill elements from index -2 to end with 15 (negative index counts from the end)
nums3.fill(15, -2);
console.log(nums3);  // Output: [8, 9, 15, 15]

4. `join()`

The join() method joins all the elements of an array into a single string. By default, the elements are separated by a comma , but you can specify a custom separator.

Syntax:

arr.join(separator);

separator (optional) – A string used to separate the array elements (default is ,).

Example:

const movies = ["Animal", "Jawan", "Pathaan"];

// Join elements with a custom separator " | "
const moviesStr = movies.join(" | ");
console.log(moviesStr);  // Output: "Animal | Jawan | Pathaan"

// The original array remains unchanged
console.log(movies);  // Output: ["Animal", "Jawan", "Pathaan"]

// Join elements with no separator
const arr = [2, 2, 1, ".", 4, 5];
console.log(arr.join(""));  // Output: "221.45"

// Join elements with a custom separator " and "
const random = [21, "xyz", undefined];
console.log(random.join(" and "));  // Output: "21 and xyz and "

Conclusion

The concat(), reverse(), fill(), and join() methods are powerful tools for working with arrays in JavaScript.

concat() combines arrays and values into a new array.
reverse() reverses the order of elements in place.
fill() replaces array elements with a specified value.
join() joins array elements into a string, with a customizable separator.

These methods are essential for effective array manipulation and can help make your code cleaner and more efficient.

6 Essential JavaScript Object Static Methods

Jenil — Sun, 15 Sep 2024 10:42:27 +0000

Just like a well-crafted movie script, JavaScript has key methods for handling objects that make coding a breeze.

Let’s dive into these essential Object static methods:

1. Object.create()

This method creates a new object with the specified prototype object and properties.

const movieObj = {
  length: 2.4,
  rating: 8.5
};
const movie1 = Object.create(movieObj);
movie1.name = 'Dunki';

// Dunki 2.4 8.5
console.log(movie1.name, movie1.length, movie1.rating);

const movie2 = Object.create(movieObj);
movie2.name = 'Salaar';
movie2.length = 2.52;

// Salaar 2.52 8.5
console.log(movie2.name, movie2.length, movie2.rating);

2. Object.assign()

This method is used to copy the values and properties from one or more source objects to a target object.

const target = { a: 10, b: 20 };
const source1 = { b: 12, c: 24 };
const source2 = { c: 29, d: 35 };

const returnedTarget = Object.assign(target, source1, source2);

// Output: { a: 10, b: 12, c: 29, d: 35 }
console.log(target);

// Output: { a: 10, b: 12, c: 29, d: 35 }
console.log(returnedTarget);

3. Object.keys()

This method returns the list of keys of object.

const movie = {
  title: 'Dunki',
  director: 'Rajkumar Hirani',
};

const keys = Object.keys(movie);

// Output: [ 'title', 'director' ]
console.log(keys);

4. Object.values()

This method returns the list of values of object.

const movie = {
  title: 'Dunki',
  director: 'Rajkumar Hirani',
};

const values = Object.values(movie);

// Output: [ 'Dunki', 'Rajkumar Hirani' ]
console.log(values);

5. Object.entries()

This method is used to get an array of key-value pairs from object.

const movie = {
  title: 'Dunki',
  director: 'Rajkumar Hirani',
};

const entries = Object.entries(movie);

// Output: [ [ 'title', 'Dunki' ], [ 'director', 'Rajkumar Hirani' ] ]
console.log(entries);

6. Object.fromEntries()

This method transforms a list of key-value pairs into an object.

const entries = 
    [ [ 'title', 'Dunki' ], [ 'director', 'Rajkumar Hirani' ] ];

const movieObj = Object.fromEntries(entries);

// Output: { title: 'Dunki', director: 'Rajkumar Hirani' }
console.log(movieObj);

With these JavaScript methods, you’re ready to direct your code like a pro! Enjoy crafting your code masterpieces! 🌟

10 JavaScript Array Methods Every Developer Should Master (Part 1)

Jenil — Sat, 07 Sep 2024 09:22:04 +0000

"With great power comes great responsibility."
— Uncle Ben, Spider-Man (2002)

Just like Spider-Man had to master his newfound powers, developers need to master the powerful arrays methods of JavaScript to code efficiently and responsibly.

Let’s dive into some of these must-know array methods!

1. find

The find() method returns the value of the first array element that satisfies the provided test function.

arr.find(callback(element, index, arr),thisArg)

Returns the value of the first element in the array that satisfies the given function.
Returns undefined if none of the elements satisfy the function

const cuties = [
  { name: "Wanda Maximoff", age: 31 },
  { name: "Natasha Romanoff", age: 32 },
  { name: "Jane Foster", age: 27 },
  { name: "Gwen Stacy", age: 26 },
];

// find method returns the value of the first element 
// in the array that satisfies the given function 
// or else returns undefined
let cuty = cuties.find(({ age }) => age >= 30);

// Output: { name: 'Wanda Maximoff', age: 31 }
console.log(cuty);

2. findIndex

The findIndex() method returns the index of the first array element that satisfies the provided test function or else returns -1.

arr.findIndex(callback(element, index, arr),thisArg)

Returns the index of the first element in the array that satisfies the given function.
Returns -1 if none of the elements satisfy the function.

const cuties = [
  { name: "Wanda Maximoff", age: 31 },
  { name: "Natasha Romanoff", age: 32 },
  { name: "Jane Foster", age: 27 },
  { name: "Gwen Stacy", age: 26 },
];

// findIndex method returns the index of the first array element 
// that satisfies the provided test function or else returns -1.
let cutyIndex = cuties.findIndex(({ age }) => age >= 30);

// Output: 0
console.log(cutyIndex);

3. indexOf

The indexOf() method returns the first index of occurance of an array element, or -1 if it is not found.

arr.indexOf(searchElement, fromIndex)

Returns the first index of the element in the array if it is present at least once.
Returns -1 if the element is not found in the array.

const productPrices = [5, 12, 3, 20, 5, 2, 50];

// indexOf() returns the first index of occurance 
// of an array element, or -1 if it is not found.
let firstIndex = productPrices.indexOf(20);
console.log(firstIndex); // 3

let secondIndex = productPrices.indexOf(5);
console.log(secondIndex); // 0

// The second argument specifies the search start index
let thirdIndex = productPrices.indexOf(5, 1);
console.log(thirdIndex); // 4

// indexOf returns -1 if not found
let notFoundIndex = productPrices.indexOf(15);
console.log(notFoundIndex); // -1

4. sort

The sort() method sorts the items of an array in a specific order (ascending or descending).

arr.sort(compareFunction)

Returns the array after sorting the elements of the array in place (meaning that it changes the original array and no copy is made).

const avengers = ["Captain", "Tony", "Thor", 
                  "Natasha", "Bruce", "Clint"];

// modifies the array in place
avengers.sort(); 

// [ 'Bruce', 'Captain', 'Clint', 'Natasha', 'Thor', 'Tony' ]
console.log(avengers);  

const nums = [1000, 50, 2, 7, 14];

// number is converted to string and sorted
nums.sort(); 

// Output: [ 1000, 14, 2, 50, 7 ]
console.log(nums) 

// sort nums in ascending order by providing compare function
nums.sort((a, b) => a - b);

// Output: [ 2, 7, 14, 50, 1000 ]
console.log(nums);

5. includes

The includes() method checks if an array contains a specified element or not.

arr.includes(valueToFind, fromIndex)

The includes() method returns:

true if is found anywhere within the array searchValue
false if is not found anywhere within the array searchValue

const avengers = ["Captain", "Tony", "Thor", 
                 "Natasha", "Bruce", "Clint"];

// includes() method returns true if an array contains 
// a specified element or else returns false.
let check1 = avengers.includes("Thor");
console.log(check1); // true 

// second argument specifies position to start the search
let check2 = avengers.includes("Thor", 3);
console.log(check2); // false

// The search starts from the 4th-to-last element ("Hulk") 
// and checks the rest of the array for "Thor". 
let check3 = avengers.includes("Thor", -4);
console.log(check3); // true

6. forEach

The forEach() method executes a provided function for each array element.

arr.forEach(callback(currentValue), thisArg)

• forEach() does not execute callback for array elements without values.

• Returns undefined.

const nums = [120, 150, 80, , 200];

// forEach() method executes a provided 
// function for each array element which 
// have values. It returns undefined.

/*
num 0: 120
num 1: 150
num 2: 80
num 4: 200
*/
nums.forEach((value, index) => {
    console.log('num ' + index + ': ' + value);
});

7. slice

The slice() method returns a shallow copy of a portion of an array into a new array object.

arr.slice(start, end)

• Returns a new array containing the extracted elements.

const fruits = ["Apple", "Banana", "Orange", "Grape", "Mango"];

// slicing the array (from start to end)
let slicedFruits1 = fruits.slice();
console.log(slicedFruits1); // [ 'Apple', 'Banana', 'Orange', 'Grape', 'Mango' ]

// slicing from the third element
let slicedFruits2 = fruits.slice(2);
console.log(slicedFruits2); // [ 'Orange', 'Grape', 'Mango' ]

// slicing from the second element to fourth element
let slicedFruits3 = fruits.slice(1, 4);
console.log(slicedFruits3); // [ 'Banana', 'Orange', 'Grape' ]

// slicing the array from start to second-to-last
let slicedFruits4 = fruits.slice(0, -1);
console.log(slicedFruits4); // [ 'Apple', 'Banana', 'Orange', 'Grape' ]

// slicing the array from third-to-last
let slicedFruits5 = fruits.slice(-3);
console.log(slicedFruits5); // [ 'Orange', 'Grape', 'Mango' ]

8. splice

The splice() method modifies an array (adds, removes or replaces elements).

arr.splice(start, deleteCount, item1, ..., itemN)

• Returns an array containing the deleted elements.

let animals = ["Dog", "Cat", "Elephant", "Lion"];

// replacing "Elephant" & "Lion" with "Tiger" & "Giraffe"
let removedAnimals1 = animals.splice(2, 2, "Tiger", "Giraffe");
console.log(removedAnimals1); // [ 'Elephant', 'Lion' ]
console.log(animals); // [ 'Dog', 'Cat', 'Tiger', 'Giraffe' ]

// adding elements without deleting existing elements
let removedAnimals2 = animals.splice(1, 0, "Elephant", "Lion");
console.log(removedAnimals2); // []
console.log(animals); // [ 'Dog', 'Elephant', 'Lion', 'Cat', 'Tiger', 'Giraffe' ]

// removing 3 elements
let removedAnimals3 = animals.splice(2, 3);
console.log(removedAnimals3); // [ 'Lion', 'Cat', 'Tiger' ]
console.log(animals); // [ 'Dog', 'Elephant', 'Giraffe' ]

9. every

The every() method checks if all the array elements pass the given test function.

arr.every(callback(currentValue), thisArg)

The every() method returns:

true - if all the array elements pass the given test function (callback returns a truthy value).
false - if any array element fails the given test function.

const nums1 = [ 1 , 2 , 3 , 4 , 5];

// every() method returns true if all the array 
// elements pass the given test function or else
// returns false
let result1 = nums1.every(element => element < 6);

// Output: true
console.log(result1); 

const nums2 = [ 1 , 2 , 7 , 4 , 5];
let result2 = nums2.every(element => element < 6);

// Output: false
console.log(result2);

10. some

The some() method tests whether any of the array elements pass the given test function.

arr.some(callback(currentValue), thisArg)

Returns true if an array element passes the given test function (callback returns a truthy value).
Otherwise, it returns false

const nums1 = [ 8 , 2 , 7 , 9 , 6];

// some() method returns true if any of the array 
// elements pass the given test function or else 
// returns false
let result1 = nums1.some(element => element < 6);

// Output: true
console.log(result1); 

const nums2 = [ 8 , 6 , 7 , 9 , 10];
let result2 = nums2.some(element => element < 6);

// Output: false
console.log(result2);

Stay tuned for Part 2 of our series, where we'll dive into even more essential JavaScript array methods! Happy Leanring!

Callbacks, Callback Hell, Promises, Async/Await

Jenil — Wed, 28 Aug 2024 18:22:38 +0000

“Coding can sometimes feel like a suspenseful movie - full of unexpected twists and turns. But what if you could make your code flow as smoothly as a well-directed scene? Welcome to the world of callbacks, promises, and async/await!”

1. Callback

A callback is a function that you pass as an argument to another function, which is then executed after the completion of that function. Think of it like this: You order a movie ticket online, and you tell them to send you an email (the callback function) when the ticket is ready.

Example:
Imagine you're ordering a ticket for the movie "Spider-Man 4" online:

function orderTicket(movie, callback) {
    console.log(`Ordering ticket for ${movie}...`);
    // Simulate a delay with setTimeout
    setTimeout(() => {
        console.log('Ticket ordered successfully!');
        callback();  // Notify when the ticket is ready
    }, 2000);
}

function notifyUser() {
    console.log('Your ticket is ready! Enjoy the movie!');
}

orderTicket('Spider-Man 4', notifyUser);

Output:

Ordering ticket for Spider-Man 4...
Ticket ordered successfully!
Your ticket is ready! Enjoy the movie!

Here, notifyUser is the callback function that gets called after the ticket is ordered.

2. Callback Hell

Callback hell happens when you have several callbacks nested inside each other, making the code hard to read and maintain. It looks like a pyramid or a staircase, and it’s difficult to follow what’s happening.

Example:
Now imagine you want to do multiple things, like ordering tickets, getting popcorn, and finding your seat, all in sequence:

function orderTicket(movie, callback) {
    console.log(`Ordering ticket for ${movie}...`);
    setTimeout(() => {
        console.log('Ticket ordered successfully!');
        callback();
    }, 2000);
}

function getPopcorn(callback) {
    console.log('Getting popcorn...');
    setTimeout(() => {
        console.log('Popcorn ready!');
        callback();
    }, 1000);
}

function findSeat(callback) {
    console.log('Finding your seat...');
    setTimeout(() => {
        console.log('Seat found!');
        callback();
    }, 1500);
}

orderTicket('Spider-Man 4', function() {
    getPopcorn(function() {
        findSeat(function() {
            console.log('All set! Enjoy the movie!');
        });
    });
});

Output:

Ordering ticket for Spider-Man 4...
Ticket ordered successfully!
Getting popcorn...
Popcorn ready!
Finding your seat...
Seat found!
All set! Enjoy the movie!

This is callback hell: you can see how the code becomes more nested and harder to read.

3. Promise

A promise is an object that represents the eventual completion (or failure) of an asynchronous operation. It allows you to write cleaner code and handle asynchronous tasks more easily without falling into callback hell.

Example:
Let’s simplify the above example using promises

function orderTicket(movie) {
    return new Promise((resolve) => {
        console.log(`Ordering ticket for ${movie}...`);
        setTimeout(() => {
            console.log('Ticket ordered successfully!');
            resolve();
        }, 2000);
    });
}

function getPopcorn() {
    return new Promise((resolve) => {
        console.log('Getting popcorn...');
        setTimeout(() => {
            console.log('Popcorn ready!');
            resolve();
        }, 1000);
    });
}

function findSeat() {
    return new Promise((resolve) => {
        console.log('Finding your seat...');
        setTimeout(() => {
            console.log('Seat found!');
            resolve();
        }, 1500);
    });
}

orderTicket('Spider-Man 4')
    .then(getPopcorn)
    .then(findSeat)
    .then(() => {
        console.log('All set! Enjoy the movie!');
    });

Output:

Ordering ticket for Spider-Man 4...
Ticket ordered successfully!
Getting popcorn...
Popcorn ready!
Finding your seat...
Seat found!
All set! Enjoy the movie!

Promises make the code easier to read by chaining .then() methods, avoiding the nesting problem.

4. Async/Await

Async/await is a modern syntax that allows you to write asynchronous code that looks and behaves like synchronous code. It’s built on top of promises and makes the code even cleaner and easier to understand.

Example:
Let’s use async/await to handle the same scenario

function orderTicket(movie) {
    return new Promise((resolve) => {
        console.log(`Ordering ticket for ${movie}...`);
        setTimeout(() => {
            console.log('Ticket ordered successfully!');
            resolve();
        }, 2000);
    });
}

function getPopcorn() {
    return new Promise((resolve) => {
        console.log('Getting popcorn...');
        setTimeout(() => {
            console.log('Popcorn ready!');
            resolve();
        }, 1000);
    });
}

function findSeat() {
    return new Promise((resolve) => {
        console.log('Finding your seat...');
        setTimeout(() => {
            console.log('Seat found!');
            resolve();
        }, 1500);
    });
}

async function watchMovie() {
    await orderTicket('Spider-Man 4');
    await getPopcorn();
    await findSeat();
    console.log('All set! Enjoy the movie!');
}

watchMovie();

Output:

Ordering ticket for Spider-Man 4...
Ticket ordered successfully!
Getting popcorn...
Popcorn ready!
Finding your seat...
Seat found!
All set! Enjoy the movie!

With async/await, the code is more straightforward, resembling the way you would describe the process in real life. The await keyword pauses the execution until the promise is resolved, making the flow of actions easy to follow.

Summary :

Callback: A function executed after another function finishes its work.
Callback Hell: Nested callbacks leading to hard-to-read code.
Promise: A cleaner way to handle asynchronous tasks, avoiding callback hell.
Async/Await: A modern, easy-to-read syntax built on promises for handling asynchronous code.

"By mastering callbacks, promises, and async/await, you can turn complex code into a seamless experience. Say goodbye to callback hell and hello to cleaner, more efficient JavaScript. Happy coding!"

10 Must-Know JavaScript Tips for Developers

Jenil — Tue, 20 Aug 2024 16:37:21 +0000

1. Looping Through an Object

Use Object.entries() to loop through key-value pairs.

const person = {
  name: 'Tony Stark',
  age: 53,
  city: 'NewYork'
};

/*
name: Tony Stark
age: 53
city: NewYork
*/
for (const [key, value] of Object.entries(person)) {
  console.log(`${key}: ${value}`);
}

Explanation:

Object.entries() converts an object’s properties into an array of key-value pairs, making it easy to iterate over them.

2. Removing Falsy Values from an Array

Use filter(Boolean) to filter out falsy values.
(Falsy values includes false, 0, '', null, undefined, and NaN)

const arr = [1, 2, 0, '', undefined, null, 3, NaN, false];

const filteredArr = arr.filter(Boolean);

console.log(filteredArr); // [1, 2, 3]

Explanation:

In this code, Boolean is passed as the callback function to filter().
The Boolean() function is a built-in function in JavaScript that returns true for truthy values and false for falsy values.
By passing Boolean as the callback function, filter() will remove all falsy values from the array arr and return a new array filteredArr with only truthy values.

3. Flattening a Multi-Dimensional Array

Use the flat() method to flatten arrays.

const multiDimensionalArray = [[1, 2], [3, 4, [5, 6]]];
const flattenedArray = multiDimensionalArray.flat(2);

// Output: [1, 2, 3, 4, 5, 6]
console.log(flattenedArray);

Explanation:

In this code, multiDimensionalArray is a two-dimensional array with two nested arrays.
By calling the flat() method with a depth of 2, all sub-array elements are concatenated into a single flat array.
The resulting flattenedArray contains all the elements of the original multi-dimensional array in a single dimension.

4. Create Array from Iterables

Use Array.from() to create an array from iterables.

// Converting String to an array
const str = "TonyStark";
const arr = Array.from(str);

// ['T', 'o', 'n', 'y', 'S', 't', 'a', 'r', 'k']
console.log(arr);

// Converting Set to an array
const set = new Set([1, 2, 3, 3, 4, 5]);
const arr = Array.from(set);
console.log(arr); // Output: [1, 2, 3, 4, 5]

Explanation:

Array.from() converts iterable or array-like objects like strings, Sets, Maps into arrays.

5. Extracting Values from Arrays

Use destructuring to extract values from an array.

const numbers = [1, 2, 3, 4, 5];
const [first, second, , fourth] = numbers;

console.log(first); // 1
console.log(second); // 2
console.log(fourth); // 4

Explanation:

Destructuring lets you assign array elements to variables directly and skip unwanted values.

6. Extracting Values from Objects

Use object destructuring to extract properties.

const person = {
  name: 'Tony Stark',
  age: 53,
  email: 'tonystark@starkindustries.com'
};

const {name, age, email} = person;

console.log(name); // Tony Stark
console.log(age); // 53
console.log(email); // tonystark@starkindustries.com

Explanation:

Destructuring extracts object properties by matching them with variables.

7. Executing Multiple Promises in Parallel

Promise.all() allows multiple promises to be executed in parallel.

const promise1 = fetch('https://api.example.com/data1');
const promise2 = fetch('https://api.example.com/data2');

Promise.all([promise1, promise2])
  .then(responses => {
    // handle responses from both requests here
    const [response1, response2] = responses;
    // do something with the responses
  })
  .catch(error => {
    // handle errors from either request here
    console.error(error);
  });

Explanation:

In this code, we create two promises using the fetch() method to fetch data from two different endpoints.
We then pass an array of promises to Promise.all() which returns a new promise that resolves when all of the promises in the array have resolved.
We can then use the responses array in the then() block to handle the responses from both requests. If either promise rejects, the catch() block will handle the error.

8. Finding the Largest and Smallest Number in an Array

Use Math.max() and Math.min() with spread syntax.

const nums = [10, 12, 29, 60, 22];
console.log(Math.max(...nums)); // 60
console.log(Math.min(...nums)); // 10

Explanation:

Spread syntax (...) expands the array elements, allowing Math.max() and Math.min() to evaluate them.

9. Converting Any Value to Boolean

Use double negation !! to convert values.

!!2; // true
!!''; // false
!!NaN; // false
!!'word'; // true
!!undefined; // false

Explanation:

Double negation (!!) in JavaScript is a trick to convert any value to its boolean equivalent.
The first ! turns truthy values to false and falsy values to true, and the second ! flips this boolean, resulting in true for truthy values and false for falsy values.

10. Swapping Variable Values

Use array destructuring to swap values.

let a = 5;
let b = 10;

// Swap values using array destructuring
[a, b] = [b, a];

console.log(a); // 10
console.log(b); // 5

Explanation:

In this example, the values of a and b are swapped without using a temporary variable.
The [b, a] on the right side creates a new array with the values of b and a, and then the destructuring assignment [a, b] on the left side assigns those values back to a and b, effectively swapping their values.

How to Insert Data into Specific Table of PostgreSQL Schemas with Node.js

Jenil — Wed, 24 Jul 2024 04:11:38 +0000

Managing PostgreSQL schemas can be complex. This post shows a Node.js script to automate schema retrieval and data insertion using the pg and fs libraries.

Prerequisites
Ensure you have:

Node.js installed on your machine.
The pg library for PostgreSQL (npm install pg).
Basic familiarity with PostgreSQL and Node.js.

Database Connection Configuration
First, set up your PostgreSQL client with the necessary connection details:

const { Client } = require('pg');
const fs = require('fs');

// Database connection configuration
const dbConfig = {
  user: 'your_username',
  host: 'your_host',
  database: 'your_database',
  password: 'your_password',
  port: 5432, // default port for PostgreSQL
};

Replace your_username, your_host, your_database, and your_password with your actual database credentials.

Retrieve Schemas
To retrieve all schemas from your PostgreSQL database, excluding default schemas, use the following function:

async function getSchemas() {
  const client = new Client(dbConfig);
  try {
    await client.connect();
    const res = await client.query(`
      SELECT schema_name
      FROM information_schema.schemata
      WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'public');
    `);
    return res.rows.map(row => row.schema_name);
  } catch (err) {
    console.error('Error retrieving schemas:', err);
  } finally {
    await client.end();
  }
}

Insert Data into Schemas
Create a function to insert data into a specific table within each schema. Replace your_table_name with the name of your target table:

async function insertDataIntoSchema(schemaName, data) {
  const client = new Client(dbConfig);

  try {
    await client.connect();
    const tableName = 'your_table_name'; // Replace with your actual table name

    const insertQuery = `
      INSERT INTO "${schemaName}"."${tableName}" ("column1", "column2", "column3")
      VALUES ($1, $2, $3)
    `;

    for (const row of data) {
      await client.query(insertQuery, [row.column1, row.column2, row.column3]);
    }

    console.log(`Data inserted into ${schemaName}.${tableName}`);
  } catch (err) {
    console.error(`Error inserting data into ${schemaName}:`, err);
  } finally {
    await client.end();
  }
}

Read JSON Data
To read and parse JSON data from a file, use the following function:

function readJSONFile(filePath) {
  return new Promise((resolve, reject) => {
    fs.readFile(filePath, 'utf8', (err, data) => {
      if (err) {
        console.error("File read error:", err);
        return reject(err);
      }
      try {
        const jsonData = JSON.parse(data);
        resolve(jsonData);
      } catch (parseErr) {
        console.error("JSON parse error:", parseErr);
        reject(parseErr);
      }
    });
  });
}

Main Function
Combine everything in the main function to fetch schemas, read JSON data, and insert it into the database:

async function main() {
  try {
    const schemas = await getSchemas();
    if (schemas && schemas.length) {
      const jsonFilePath = './path/to/your/json_file.json'; // Replace with your JSON file path
      const data = await readJSONFile(jsonFilePath);
      for (const schema of schemas) {
        await insertDataIntoSchema(schema, data);
      }
    } else {
      console.log('No schemas found.');
    }
  } catch (err) {
    console.error('Error in main function:', err);
  }
}

main().catch(err => console.error('Error in main function:', err));

Conclusion
This Node.js script simplifies the process of managing PostgreSQL schemas and inserting data. By automating these tasks, you can handle complex database operations more efficiently. Adapt the script to suit your specific needs and integrate it into your workflow to boost productivity.

Feel free to ask questions or share your enhancements in the comments!

DEV Community: Jenil

4 JavaScript Array Methods Every Developer Should Master (Part 2)

1. concat()

Syntax:

Example:

2. reverse()

Syntax:

Example:

3. fill()

Syntax:

Example:

4. join()

Syntax:

Example:

Conclusion

6 Essential JavaScript Object Static Methods

1. Object.create()

2. Object.assign()

3. Object.keys()

4. Object.values()

5. Object.entries()

6. Object.fromEntries()

10 JavaScript Array Methods Every Developer Should Master (Part 1)

1. find

2. findIndex

3. indexOf

4. sort

5. includes

6. forEach

7. slice

8. splice

9. every

10. some

Callbacks, Callback Hell, Promises, Async/Await

1. Callback

2. Callback Hell

3. Promise

4. Async/Await

Summary :

10 Must-Know JavaScript Tips for Developers

1. Looping Through an Object

2. Removing Falsy Values from an Array

3. Flattening a Multi-Dimensional Array

4. Create Array from Iterables

5. Extracting Values from Arrays

6. Extracting Values from Objects

7. Executing Multiple Promises in Parallel

8. Finding the Largest and Smallest Number in an Array

9. Converting Any Value to Boolean

10. Swapping Variable Values

How to Insert Data into Specific Table of PostgreSQL Schemas with Node.js

1. `concat()`

2. `reverse()`

3. `fill()`

4. `join()`