Install PostgreSQL in a Docker Container

Aung Thu Oo — Sun, 22 Sep 2024 09:03:55 +0000

Install PostgreSQL in a Docker Container: A Beginner's Guide

1. Prerequisites

Docker installed on your machine
Node.js installed on your machine

2. Preparation

Create any folder you want, and then open it with your terminal.

mkdir <YOUR_FOLDER>
cd <YOUR_FOLDER>
code .

3. Initialize a git repository.

git init
touch .gitignore

Populate the .gitignore file with the following content:

*node_modules

Create a file called compose.yaml in the project's root.

touch compose.yaml

4. Database

I will use Postgres but not install it on my machine. Instead, I will use Docker to run it in a container. This way, I can easily start and stop the database without installing it on my machine.

Open the file compose.yaml and add the following content:

version: '3.9'

services:
  db:
    container_name: pgdb
    image: postgres:12
    restart: always
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: postgres
    ports:
      - 5432:5432
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata: {}

then type in your terminal

docker compose up -d

This will pull the Postgres image from Docker Hub and start the container.
The -d flag means that the container will run in detached mode so we can continue to use the terminal.

5.Testing

To check if the container is running:

docker ps -a

Step into the db container

docker exec -it pgdb psql -U postgres

Now that you are in the Postgres container, you can type:

\l

\dt

And you should see no relations.

You can now exit the container with the exit command.

exit

What is Throttling?

Aung Thu Oo — Tue, 21 May 2024 02:55:38 +0000

Throttling is a technique used to limit the rate at which a function is called. Throttling transforms a function such that it can only be called once in a specific interval of time.

First understand what we want to achieve with throttling:

Call the function immediately the first time.
After each call, prevent the function from being called again for a certain time period.
Once that time period has passed, the function can be called again. To do all this, let's first create a helper function that will return a throttled function:

Next, we'll declare a variable timeout that will be initialized only once in the outer function (that is the throttle() function). The setTimeout method returns a unique timeout id that we can use to identify a timeout. We'll assign the current timeout id to timeout.

function throttle(func, delay) {
    let timeout=null
    return () => {
        if(!timeout) {
            func()
            timeout=setTimeout(() => {
                // do something
            }, delay)
        }
    }
}

Implement Throttling using a React.js Custom Hook

We'll write the throttling logic inside a custom hook. Since you may need throttling in multiple places in your application, it is recommended to put the logic inside a custom hook.

Create a new folder called custom-hooks. Inside it, create a file useThrottle.js. Inside the file, create and export new function useThrottle(). The method should take a function and delay as parameters and return the throttled function.

const useThrottle = (func, delay) => {
  let timeout = null;
  return (...args) => {
    if (timeout) {
      return;
    }
    func(...args);
    timeout = setTimeout(() => {
      timeout = null;
    }, delay);
  };
};

export default useThrottle;

Now, inside the App component, call this method and pass the click handler handleClick() and a delay of 1000ms.

const handleClickThrottled = useThrottle(handleClick, 1000);

We'll use this function as the event handler for our button.

<button onClick={handleClickThrottled}>Click Me</button>

DEV Community: Aung Thu Oo