# Introduction

Database Schema Migration is the process of updating a Collection Schema and/or adapting the existing data for new requirements.

The objective of this post is to learn about the different ways a migration tool can help us to write scripts that modify your database by adding new documents, modifying existing ones, or changing the collection schema.

[![1](https://softwareontheroad.com/static/f0c686a5fb90fb522c223340e584880b/4a896/1.jpg)](https://softwareontheroad.com/static/f0c686a5fb90fb522c223340e584880b/8299d/1.jpg)

# This is why you need a migration tool for MongoDB

We know that mongo is a non-relational database schema-free database, but in most of the projects, we tend to use it with Mongoose, a popular ODM for MongoDB which allows us to add Schema to our collections.

And as software evolves, we may need to fix mistakes on the data schema or adapt existing data as requirements change.

Now the problem is that we can’t rely on running manual update commands on the MongoDB shell since that is prone to errors or some times we need a special tool like `lodash` or `moment` to perform some modifications to dates or arrays.

Also, when we need to perform several updates that have a special order, it is pretty common to mix those up and broke the data.

The solution is to use a specialized tool, such as the npm package `migrate-mongo`

This way we will have an incremental, reversible, and version-controlled way to handle database schema migrations.

# Example of use cases

Let’s explore some use cases for MongoDB migrations:

- Adding new relations to existing collections. For example, in an e-commerce app, you added a new entity like ‘brand’ and now you need to update certain ‘products’ to have a relation to that brand.
- Renaming fields. Useful when you need to change a field that, for example, was named `created` and now will be `signupDate`.
- Adding fields to existing documents. Sometimes (or a lot of times) as your app grows you, find that the database schemas you designed the first time need to be expanded. For example, adding a field `quantity` to a `products` table in order to model the current stock.
- Separating fields into new document properties. A classic example is having a field `name` that now is divided into `firstName` and `lastName`

[![3](https://softwareontheroad.com/static/d3b2ad135e54ee65385065466751ee77/8ba71/3.jpg)](https://softwareontheroad.com/static/d3b2ad135e54ee65385065466751ee77/8ba71/3.jpg)

# Using the migration tool

While there is a variety of tools to perform migrations, my favorite is `migrate-mongo` because it’s well documented and actively developed.

To install it:

```text
npm install -g migrate-mongo
```

I installed it globally, but you can also install it locally on your project and then invoke it from an npm command [(see about it in next section)](https://softwareontheroad.com/database-migration-node-mongo/#migration-tool-running) Or you can even use `npx` to avoid installing it on your server.

## Let’s now see how to use it.

The first step is to init the migrations tool

```text
migrate-mongo init
```

This will create a `migrate-mongo-config.js` configuration file and a `migrations` folder at the root of our project.

```text
|_ src/
|_ migrations/
   |- 20200606204524-migration-1.js
   |- 20200608124524-migration-2.js
   |- 20200808114324-migration-3.js
|- migrate-mongo.js
|- package.json
|- package-lock.json
```

## Migrate-mongo configuration file

In the configuration file, we can define our database URL, I have it stored on a config file in another folder, where it loads it depending on the environment (such as local, staging, production) Also, we can change the MongoDB connection parameters, and finally, in which collection, the current database version will be saved.

```js
// In this file you can configure migrate-mongo
const env = require('./server/config')
const config = {
  mongodb: {
    // TODO Change (or review) the url to your MongoDB:
    url: env.mongo.url || "mongodb://localhost:27017",

    // TODO Change this to your database name:
    databaseName: env.mongo.dbname || "YOURDATABASENAME",

    options: {
      useNewUrlParser: true, // removes a deprecation warning when connecting
      useUnifiedTopology: true, // removes a deprecating warning when connecting
      //   connectTimeoutMS: 3600000, // increase connection timeout up to 1 hour
      //   socketTimeoutMS: 3600000, // increase socket timeout up to 1 hour
    }
  },

  // The migrations dir can be a relative or absolute path. Only edit this when really necessary.
  migrationsDir: "migrations",

  // The MongoDB collection where the applied changes are stored. Only edit this when really necessary.
  changelogCollectionName: "changelog"
};
module.exports = config;
```

## Migrations folder

Inside the migrations folder, our scripts will be sorted by date.

The date is appended to the beginning of the file name.

```text
|_ migrations/
   |- 20200606204524-change-name-to-full-name.js
   |- 20200608124524-add-user-default-picture.js
   |- 20200808114324-remove-old-property.js
   |- 20210108114324-change-password-hashing.js
```

That way the tool ensures us the scripts will be run in order.

## Adding a migration

To add a new migration script, use the CLI command

```text
migrate-mongo create name-of-my-script
```

A new file will be created with a corresponding timestamp.

```text
|_ migrations/
   |- 20210108114324-name-of-my-script.js
```

## The up function

The script file expects us to export an object with a UP function and a DOWN function.

When the scripts are applied, the up function is responsible for changing the database schema.

```js
module.exports = {
    function up(db) {
        return db.collection('products').updateMany({}, { $set: { quantity: 10 } })
    }
    
    function down(db) {
        return db.collection('products').updateMany({}, { $unset: { quantity: null } })
    }
}
```

[![2](https://softwareontheroad.com/static/853c0599b9c3eeefb8dce59877f74e4f/4a896/2.jpg)](https://softwareontheroad.com/static/853c0599b9c3eeefb8dce59877f74e4f/8299d/2.jpg)

But don’t limit yourself by this simple file, it is a regular js file where you can import/require any library that you need (lodash.js / moment.js / etc)

Here is an example that sets an additional field that needs to be calculated using moment.js

```js
const moment = require('moment');

module.exports = {
    async   function up(db) {
    const products = await db.collection.get('products').find({}).toArray();
        const operations = products.map((product) => {
            return db.collection('products').updateOne({ _id: product._id }, {
                    $set: {
                        weekDay: moment(product.date).day()
                    }
            })          
        })
        return Promise.all(operations);
    }
    
    function down(db) {
        return db.collection('products')
                    .updateMany({}, { $unset: { weekDay: null } });
    }
}
```

## The down function

This is how you go back to the previous database state.

```js
module.exports = {
    function up(db) {
        return db.collection('users').updateMany({}, { $rename: { name: "fullName" } })
    }
    
    function down(db) {
        return db.collection('users').updateMany({}, { $rename: { fullName: "name" } })
    }
}
```

It is not always possible to go back to the previous state

```js
module.exports = {
    function up(db) {
        return db.collection('users').deleteMany({ name: /Sam/ })
    }
    
    function down(db) {
        // But we can't recover deleted documents...
        return Promise.resolve('ok')
    }
}
```

## The database changelog

In order to know the current database version and which migration should apply next, there is a special collection that stores the database changelog with information such as migrations applied, and when where they applied.

[![2](https://softwareontheroad.com/static/a39b8e76e3af8af3167fb9ce9a889bcc/15740/changelog.jpg)](https://softwareontheroad.com/static/a39b8e76e3af8af3167fb9ce9a889bcc/15740/changelog.jpg)

## Running migrations

To run your migrations, simply run the command

```bash
migrate-mongo up
```

Also, you can add it to your package.json as an npm script

```json
{
    "scripts": {
        "migrate:up": "migrate-mongo up",
        "migrate:down": "migrate-mongo down"
    }
}
```

This `up` command will run every migration that wasn’t already applied to your database. It uses the changelog collection to know the current database state and version.

To rollback a migration use the `down` command:

```bash
migrate-mongo down
```

This will only roll back one single migration, the latest applied.

# Automated migrations

The way to run this on your production/staging server is by using a simple script after the `npm install` and before the start of the server

### Heroku

According to Heroku’s documentation for node.js you may specify a post-build script that is executed every time a new update is sent.

Inside your package.json

```json
"scripts": {
  "heroku-postbuild": "migrate-mongo up",
}
```

You can read more about Heroku build steps here:

https://devcenter.heroku.com/articles/nodejs-support#heroku-specific-build-steps

### Digital Ocean

On D.O things vary depending on your setup, but what we aim is to execute the migrate tool after the node.js dependencies installation process, but before starting up the node.js application.

For example, here is a bash script that can be executed by login-in through ssh into the digital ocean droplet.

```bash
# Go to the app folder
cd ~/apps/my-app
# Install all dependencies
npm install
# Run migrations
migrate-mongo up
# Restart the node.js app
pm2 restart my-app
```

# Conclusion

By using a database schema migration tool you will archive incremental, reversible, and version-controlled way to apply schema and data changes.

With the tool `migrate-mongo` we can have all of that and if we combine it with the power of continuous delivery applied to Heroku or Digital Ocean we are ready to scale!

All you need to know about MongoDB schema migrations in node.js

### Query to check if the database is CDB or non-CDB

Suppose you want to know if the target database is CDB (container database ) or Non-CDB ( Normal Non-container database). You can log in to the DB Box and source the Oracle DB and then find using the below query

```
sqlplus / as sysdba
SELECT NAME, CDB, CON_ID FROM V$DATABASE;

NAME CDB CON_ID
--------------------------- --------- ----------
CDB01 YES 0
```

### how to check container database in oracle 12c

Query to check containers in the CDB database. Each PDB and root is a container

```
SQL> alter session set container=CDB$ROOT;

Session altered.

SQL> select CON_ID, NAME, OPEN_MODE, TOTAL_SIZE from v$containers;

CON_ID NAME OPEN_MODE TOTAL_SIZE
---------- -------------------- ------------------------------ ----------
1 CDB$ROOT READ WRITE 0
2 PDB$SEED READ ONLY 891289600
3 SEED READ WRITE 1248961280
4 TEST READ WRITE  1248961280
5 TEST2 READ WRITE 1248961280
```

If you are connected to a PDB, it will show that container only

```
SQL> alter session set container=PDB$SEED;
SQL> select CON_ID, NAME, OPEN_MODE, TOTAL_SIZE from v$containers;

CON_ID NAME OPEN_MODE TOTAL_SIZE
---------- -------------------- ------------------------------ ----------
2 PDB$SEED READ ONLY 891289600
```

### Query to check PDB in the CDB database.

Connected to root container

```
SQL> alter session set container=CDB$ROOT;

Session altered.

select CON_ID,DBID,NAME,OPEN_MODE from v$pdbs;

CON_ID DBID NAME OPEN_MODE
---------- ---------- -------------------- ------------------------------
2 5604597646 PDB$SEED READ ONLY
3 823307170 SEED READ WRITE
4 458722011 TEST READ WRITE

SQL> show pdbs

CON_ID CON_NAME OPEN MODE RESTRICTED
---------- ------------------------------ ---------- ----------
2 PDB$SEED READ ONLY NO
3 SEED READ WRITE NO
4 TEST READ WRITE NO
```

Connected to a particular PDB

```
SQL> alter session set container=SEED;

Session altered.

SQL> select CON_ID,DBID,NAME,OPEN_MODE from v$pdbs
2 ;

CON_ID DBID NAME OPEN_MODE
---------- ---------- -------------------- ------------------------------
3 823307170 SEED READ WRITE

SQL> show pdbs

CON_ID CON_NAME OPEN MODE RESTRICTED
---------- ------------------------------ ---------- ----------
3 SEED READ WRITE NO
SQL>
```

### Startup and shutdown of PDB

Connected to root container

```
alter pluggable database test1_tech close;

alter pluggable database test1_tech close immediate;

alter pluggable database test1_tech open;

alter pluggable database test1_tech open read only ;

alter pluggable database test1_tech open force;
```

If the container is set, we can use the below command

```
ALTER PLUGGABLE DATABASE CLOSE IMMEDIATE;
ALTER PLUGGABLE DATABASE OPEN READ ONLY;
ALTER PLUGGABLE DATABASE OPEN FORCE;

ALTER PLUGGABLE DATABASE NOLOGGING;

ALTER PLUGGABLE DATABASE ENABLE FORCE LOGGING;

STARTUP OPEN
STARTUP OPEN READ ONLY
STARTUP RESTRICT OPEN READ ONLY
```

### How to add service in CDB

```
srvctl add service -db CDB01 -service TEST_NEW -pdb TEST
srvctl modify service -db CDB01 -service TEST_NEW -pdb TEST
srvctl remove service -db CDB01 -service TEST_NEW

BEGIN
DBMS_SERVICE.CREATE_SERVICE(
service_name => 'TEST_NEW',
network_name => 'TEST_NEW.com');
END;
/

BEGIN
DBMS_SERVICE.DELETE_SERVICE(
service_name => 'TEST_NEW');
END;
/

SQL> select name, con_id from v$active_services order by 1;

NAME CON_ID
-------------------- ----------
CDB01 1
CDB01XDB 1
SYS$BACKGROUND 1
SYS$USERS 1
TEST 4
seed 3

6 rows selected.
```

### Show command with 12c database

```
show con_name

CON_NAME
------------------------------
CDB$ROOT

show con_id

CON_ID
------------------------------
1
```

### How to close and open all the PDB in a single command

```
alter pluggable database all close immediate;

alter pluggable database all open;
```

### How to drop the pluggable database

```
drop pluggable database pdb3_test including datafiles;
```

### Container storage

With the root container, we have cdb_tablespaces,cdb_data_files shows the tablespace and data files of all the containers in the CDB, and dba_tablespaces,dba_data_files will show the root tablespace and datafiles only

```
alter session set container=CDB$ROOT;

SQL> select tablespace_name, con_id from cdb_tablespaces;

TABLESPACE_NAME CON_ID
------------------------------------------------------------------------------------------ ----------
SYSTEM 1
SYSAUX 1
UNDOTBS1 1
TEMP 1
USERS 1

SYSTEM 2
SYSAUX 2

SQL> select tablespace_name from dba_tablespaces;

TABLESPACE_NAME
------------------------------------------------------------------------------------------ ----------
SYSTEM
SYSAUX
UNDOTBS1
TEMP
USERS
```

When connected to a PDB, cdb_tablespaces,cdb_data_files shows the same information as dba_tablespaces,dba_data_files for the PDB

### How to rename the pluggable database

Here is the sql command to rename the pluggable database

```sql
alter pluggable database TEST rename global_name to TEST1;
```

### How to check for the Local Undo feature in 12.2

Here is the query to check for the Local Undo feature in Oracle database 12.2. This feature enables local undo tablespace for each of the pdb’s

```
COLUMN property_name FORMAT A30
COLUMN property_value FORMAT A30

SELECT property_name, property_value
FROM database_properties
WHERE property_name = 'LOCAL_UNDO_ENABLED';

PROPERTY_NAME PROPERTY_VALUE
------------------------------ ------------------------------
LOCAL_UNDO_ENABLED TRUE
```

### Viewing the History of PDBs

```
COLUMN DB_NAME FORMAT A10
COLUMN CON_ID FORMAT 999
COLUMN PDB_NAME FORMAT A15
COLUMN OPERATION FORMAT A16
COLUMN OP_TIMESTAMP FORMAT A10
COLUMN CLONED_FROM_PDB_NAME FORMAT A15
SELECT DB_NAME, CON_ID, PDB_NAME, OPERATION, OP_TIMESTAMP, CLONED_FROM_PDB_NAME
FROM CDB_PDB_HISTORY
WHERE CON_ID > 2
ORDER BY CON_ID;
```

I hope you like the compilation of these useful Oracle 12c pluggable database commands. Please provide feedback on it and tell me what else can be added to this list

Useful Oracle 12c Pluggable database commands

## Change Git Remote URL

**In order to change the URL of a Git remote, you have to use the “git remote set-url” command and specify the name of the remote as well as the new remote URL to be changed.**

```bash
$ git remote set-url <remote_name> <remote_url>
```

For example, let’s say that you want to **change the URL of your Git origin remote**.

In order to achieve that, you would use the “set-url” command on the “origin” remote and you would specify the new URL.

```
$ git remote set-url origin https://git-repo/new-repository.git
```

![git change remote using set url](https://devconnected.com/wp-content/uploads/2020/02/set-url.png)

Congratulations, **you successfully changed the URL of your Git remote!**

In order to verify that the changes were made, you can use the “git remote” command with the “-v” option (for verbose)

```
$ git remote -v
```

![list remote using git remote](https://devconnected.com/wp-content/uploads/2020/02/list-remotes.png)

How To Change Git Remote Origin

TABLE_EXISTS_ACTION parameter is required while importing table, which is already present in the database. We can put required value, according to our requirement.

 

> **TABLE_EXISTS_ACTION**
> **Action to take if** imported **object already exists.**
> **Valid keywords are: APPEND, REPLACE, [SKIP] and TRUNCATE.**
>
>  

**TABLE_EXISTS_ACTION=APPEND:**

With this option, while importing the table, if the table exists in the database, then it will append the data on top the existing data in the table.

```
select count(*) from "DBATEST"."EMP_TAB";

COUNT(*)
----------
175340


impdp dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=APPEND


Starting "SYS"."SYS_IMPORT_FULL_01": /******** AS SYSDBA dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=APPEND
Processing object type TABLE_EXPORT/TABLE/TABLE
Table "DBATEST"."EMP_TAB" exists. Data will be appended to existing table but all dependent metadata will be skipped due to table_exists_action of append
Processing object type TABLE_EXPORT/TABLE/TABLE_DATA
. . imported "DBATEST"."EMP_TAB" 19.16 MB 175340 rows
Job "SYS"."SYS_IMPORT_FULL_01" successfully completed at Tue Jan 24 08:57:09 2017 elapsed 0 00:01:18


SQL[SYS@]SQL>>]select count(*) from "DBATEST"."EMP_TAB";

COUNT(*)
----------
350680
```



**TABLE_EXISTS_ACTION=TRUNCATE:**

While importing the table, if the table exists in database, it will truncate the table and load the data.

```
impdp dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=TRUNCATE

Starting "SYS"."SYS_IMPORT_FULL_01": /******** AS SYSDBA dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=TRUNCATE
Processing object type TABLE_EXPORT/TABLE/TABLE
Table "DBATEST"."EMP_TAB" exists and has been truncated. Data will be loaded but all dependent metadata will be skipped due to table_exists_action of truncate
Processing object type TABLE_EXPORT/TABLE/TABLE_DATA
. . imported "DBATEST"."EMP_TAB" 19.16 MB 175340 rows
Job "SYS"."SYS_IMPORT_FULL_01" successfully completed at Tue Jan 24 09:02:23 2017 elapsed 0 00:01:11
```

**TABLE_EXISTS_ACTION=REPLACE:**

While importing , if the table exists in database, then it will drop it and recreate it from the dump

```
impdp dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=REPLACE

Starting "SYS"."SYS_IMPORT_FULL_01": /******** AS SYSDBA dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN table_exists_action=REPLACE
Processing object type TABLE_EXPORT/TABLE/TABLE
Processing object type TABLE_EXPORT/TABLE/TABLE_DATA
. . imported "DBATEST"."EMP_TAB" 19.16 MB 175340 rows
Job "SYS"."SYS_IMPORT_FULL_01" successfully completed at Tue Jan 24 09:20:30 2017 elapsed 0 00:01:37
```



**TABLE_EXISTS_ACTION=SKIP:**

This is the defult option with impdp. I.e if the the table exists, it will skip that table.

```
Starting "SYS"."SYS_IMPORT_FULL_01": /******** AS SYSDBA dumpfile=emp_tab.dmp logfile=emp_tab.log directory=VEN
Processing object type TABLE_EXPORT/TABLE/TABLE
ORA-39151: Table "DBATEST"."EMP_TAB" exists. All dependent metadata and data will be skipped due to table_exists_action of skip
Processing object type TABLE_EXPORT/TABLE/TABLE_DATA
Job "SYS"."SYS_IMPORT_FULL_01" completed with 1 error(s) at Tue Jan 24 09:31:51 2017 elapsed 0 00:01:01
```

TABLE_EXISTS_ACTION Option In IMPDP

If you need to copy a list of files from a folder in Windows there’s a better way to do that than copying and pasting each file title. Instead, you can set up a Notepad text document with all the file titles in a folder from the Command Prompt.

Firstly, open the Command Prompt by entering cmd in the Windows Start menu search box. Alternatively, press the Windows key + R to open Run; and then enter cmd.exe. That should then open the Command Prompt window in the shot below.

[![file list](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list.jpg?7653)](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list.jpg?7653)

There you should go to the folder directory that includes the files to copy. To switch directories in the Command Prompt, enter CD followed by the folder titles. For example, to open the Windows folder you would enter CD\Windows.

[![file list2](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list2.jpg?7653)](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list2.jpg?7653)[
](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list.jpg?7653)

Once you’ve found the folder with the files in it, you should then enter the following: **dir /b >filename.txt**. Note that the filename is the title of the text document that will include the list of files. As such, you can change the filename to any other alternative document tile; but enter the rest of the command line exactly the same as below.

[![file list3](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list3.jpg?7653)](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list3.jpg?7653)

Then press Enter to set up the text document. Open Windows Explorer, and go to the folder that you copied the file titles from. You should now find that it includes a new text file with a list of all the files in the folder as below.

[![file list4](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list4-620x444.jpg?7653)](https://dt.azadicdn.com/wp-content/uploads/2014/05/file-list4.jpg?7653)

Now you can copy a variety of folder file lists much the same. They include both the file titles and formats, but little else. Those lists can be copied from Notepad into alternative software packages with which you can add line numbering, bullet points, etc if required.

How to copy all the file names in a folder in Windows

A recursive function is a [function](https://www.javascripttutorial.net/javascript-function/) that calls itself until it doesn’t. And this technique is called recursion.

Suppose that you have a function called `recurse()`. The `recurse()` is a recursive function if it calls itself inside its body, like this:

```js
function recurse() {
    // ...
    recurse();
    // ...
}
```

A recursive function always has a condition to stop calling itself. Otherwise, it will call itself indefinitely. So a recursive function typically looks like the following:

```js
function recurse() {
    if(condition) {
        // stop calling itself
        //...
    } else {
        recurse();
    }
}
```

Generally, you use recursive functions to break down a big problem into smaller ones. Typically, you will find the recursive functions in data structures like binary trees and graphs and algorithms such as binary search and quicksort.

## JavaScript recursive function examples

Let’s take some examples of using recursive functions.

### 1) A simple JavaScript recursive function example

Suppose that you need to develop a function that counts down from a specified number to 1. For example, to count down from 3 to 1:

```
3
2
1
```

The following shows the `countDown()` function:

```js
function countDown(fromNumber) {
    console.log(fromNumber);
}

countDown(3);
```

This `countDown(3)` shows only the number 3.

To count down from the number 3 to 1, you can:

1. show the number 3.
2. and call the `countDown(2)` that shows the number 2.
3. and call the `countDown(1)` that shows the number 1.

The following changes the `countDown()` to a recursive function:

```js
function countDown(fromNumber) {
    console.log(fromNumber);
    countDown(fromNumber-1);
}

countDown(3);
```

This `countDown(3)` will run until the call stack size is exceeded, like this:

```bash
Uncaught RangeError: Maximum call stack size exceeded.Code language: JavaScript (javascript)
```

… because it doesn’t have the condition to stop calling itself.

The count down will stop when the next number is zero. Therefore, you add an [if condition](https://www.javascripttutorial.net/javascript-if/) as follows:

```js
function countDown(fromNumber) {
    console.log(fromNumber);

    let nextNumber = fromNumber - 1;

    if (nextNumber > 0) {
        countDown(nextNumber);
    }
}
countDown(3);
```

Output:

```
3
2
1
```

The `countDown()` seems to work as expected.

However, as mentioned in the [Function type tutorial](https://www.javascripttutorial.net/javascript-function-type/), the function’s name is a reference to the actual function object.

If the function name is set to `null` somewhere in the code, the recursive function will stop working.

For example, the following code will result in an error:

```js
let newYearCountDown = countDown;
// somewhere in the code
countDown = null;
// the following function call will cause an error
newYearCountDown(10);
```

Error:

```bash
Uncaught TypeError: countDown is not a functionCode language: JavaScript (javascript)
```

How the script works:

- First, assign the `countDown` function name to the variable `newYearCountDown`.
- Second, set the `countDown` function reference to `null`.
- Third, call the `newYearCountDown` function.

The code causes an error because the body of the `countDown()` function references the `countDown` function name, which was set to `null` at the time of calling the function.

To fix it, you can use a named function expression as follows:

```js
let countDown = function f(fromNumber) {
    console.log(fromNumber);

    let nextNumber = fromNumber - 1;

    if (nextNumber > 0) {
        f(nextNumber);
    }
}

let newYearCountDown = countDown;
countDown = null;
newYearCountDown(10);
```

### 2) Calculate the sum of n natural numbers example

Suppose you need to calculate the sum of natural numbers from 1 to n using the recursion technique. To do that, you need to define the `sum()` recursively as follows:

```js
sum(n) = n + sum(n-1)
sum(n-1) = n - 1 + sum(n-2)
...
sum(1) = 1
```

The following illustrates the `sum()` recursive function:

```js
function sum(n) {
  if (n <= 1) {
    return n;
  }
  return n + sum(n - 1);
}
```

## Summary

- A recursive function is a function that calls itself until it doesn’t
- A recursive function always has a condition that stops the function from calling itself.

JavaScript Recursive Function

The Levenshtein distance is a string metric for measuring the difference between two sequences. It is the minimum number of single-character edits required to change one word into the other.

### For example −
Consider, we have these two strings −

```js
const str1 = 'hitting';
const str2 = 'kitten';
```

The Levenshtein distance between these two strings is 3 because we are required to make these three edits −
- kitten → hitten (substitution of "h" for "k")
- hitten → hittin (substitution of "i" for "e")
- hittin → hitting (insertion of "g" at the end)

We are required to write a JavaScript function that takes in two strings and calculates the Levenshtein distance between them.

### Example
Following is the code −

```js
const str1 = 'hitting';
const str2 = 'kitten';
const levenshteinDistance = (str1 = '', str2 = '') => {
   const track = Array(str2.length + 1).fill(null).map(() =>
   Array(str1.length + 1).fill(null));
   for (let i = 0; i <= str1.length; i += 1) {
      track[0][i] = i;
   }
   for (let j = 0; j <= str2.length; j += 1) {
      track[j][0] = j;
   }
   for (let j = 1; j <= str2.length; j += 1) {
      for (let i = 1; i <= str1.length; i += 1) {
         const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
         track[j][i] = Math.min(
            track[j][i - 1] + 1, // deletion
            track[j - 1][i] + 1, // insertion
            track[j - 1][i - 1] + indicator, // substitution
         );
      }
   }
   return track[str2.length][str1.length];
};
console.log(levenshteinDistance(str1, str2));
```
### Output
Following is the output on console −

```bash
3
```

Levenshtein Distance in JavaScript

You might have come across multiple instances where you will have to use checkboxes like agreeing to terms and conditions, selecting a list of preferences, etc. In this article, we will learn different scenarios of using checkboxes in React.

First, let's create a simple checkbox component as shown below:

App.js

```jsx
export const Checkbox = () => {
  return (
    <div>
      <input type="checkbox" id="checkbox" />
      <label htmlFor="checkbox">I agree to Terms of Service </label>
    </div>
  );
};
function App() {
  return (
    <div className="App">
      <Checkbox />
    </div>
  );
}
export default App;

```

Now if you test the application, you will see that you can check and uncheck the checkbox. But how do we know the current state of the checkbox?

## Storing and Reading the checkbox state

We can make use of the useState hook to store the state of the checkbox.

App.js

```jsx
import { useState } from "react";
export const Checkbox = () => {
  const [isChecked, setIsChecked] = useState(false);
  return (
    <div>
      <input type="checkbox" id="checkbox" checked={isChecked} />
      <label htmlFor="checkbox">I agree to Terms of Service </label>
      <p>The checkbox is {isChecked ? "checked" : "unchecked"}</p>
    </div>
  );
};
function App() {
  return (
    <div className="App">
      <Checkbox />
    </div>
  );
}
export default App;

```

Now if you try to check the checkbox, nothing would happen and you will see the following warning in the console:

```
You provided a checked prop to a form field without an onChange handler. This will render a read-only field. If the field should be mutable use defaultChecked. Otherwise, set either onChange or readOnly.
```

Why does this happen? As the warning suggests, we are just setting the value of the state to the checkbox and not doing anything while the checkbox state changes. So let's bind an on change handler:

App.js

```jsx
import { useState } from "react";
export const Checkbox = () => {
  const [isChecked, setIsChecked] = useState(false);
  const checkHandler = () => {
    setIsChecked(!isChecked);
  };
  return (
    <div>
      <input type="checkbox" id="checkbox" checked={isChecked} onChange={checkHandler} />
      <label htmlFor="checkbox">I agree to Terms of Service </label>
      <p>The checkbox is {isChecked ? "checked" : "unchecked"}</p>
    </div>
  );
};
function App() {
  return (
    <div className="App">
      <Checkbox />
    </div>
  );
}
export default App;

```

If you want the checkbox to be checked initially, then you can pass `true` to the useState hook while initializing it.

## Checkbox using uncontrolled input

The above example we have seen is using controlled inputs. Next, we will see how to implement the same using uncontrolled inputs. I have explained the difference between controlled and uncontrolled inputs in my [previous article](https://www.codingdeft.com/posts/react-controlled-uncontrolled/).

App.js

```jsx
import { useRef } from "react";
function App() {
  const checkboxRef = useRef(null);
  const formSubmitHandler = (e) => {
    e.preventDefault();
    alert(`The checkbox is ${checkboxRef.current.checked ? "checked" : "unchecked"}`);
  };
  return (
    <div className="App">
      <form onSubmit={formSubmitHandler}>
        <input type="checkbox" id="checkbox" defaultChecked={true} ref={checkboxRef} />
        <label htmlFor="checkbox">I agree to Terms of Service </label>
        <p>
          <button type="submit">Submit</button>
        </p>
      </form>
    </div>
  );
}
export default App;

```

Here we are providing the initial value using `defaultChecked` prop. We have created a reference to the checkbox so that we can access the value of the checkbox inside the form submit handler. Here we are not using any state to store the current state of the checkbox. It is stored in the DOM itself.

It is always recommended to use controlled components over uncontrolled components because as the name suggests, we have more control over the input.

## Reusing the checkbox component for displaying multiple checkboxes

First, let's make the checkbox component that we created earlier as a reusable component:

```jsx
import { useState } from "react";
export const Checkbox = ({ isChecked, label, checkHandler }) => {
  return (
    <div>
      <input type="checkbox" id="checkbox" checked={isChecked} onChange={checkHandler} />
      <label htmlFor="checkbox">{label}</label>
    </div>
  );
};
function App() {
  const [isChecked, setIsChecked] = useState(false);
  const checkHandler = () => {
    setIsChecked(!isChecked);
  };
  return (
    <div className="App">
      <Checkbox
        isChecked={isChecked}
        checkHandler={checkHandler}
        label="I agree to Terms of Service"
      />
      <p>The checkbox is {isChecked ? "checked" : "unchecked"}</p>
    </div>
  );
}
export default App;

```

Now let's say you have a use case where you want to display a list of pizza toppings, from which you want the users to choose. We can achieve that by the following code:

App.js

```jsx
import { useState } from "react";
const allToppings = [
  { name: "Golden Corn", checked: false },
  { name: "Paneer", checked: false },
  { name: "Tomato", checked: false },
  { name: "Mushroom", checked: false },
  { name: "Onion", checked: false },
  { name: "Black Olives", checked: false },
];

export const Checkbox = ({ isChecked, label, checkHandler, index }) => {
  return (
    <div>
      <input type="checkbox" id={`checkbox-${index}`} checked={isChecked} onChange={checkHandler} />
      <label htmlFor={`checkbox-${index}`}>{label}</label>
    </div>
  );
};

function App() {
  const [toppings, setToppings] = useState(allToppings);
  const updateCheckStatus = (index) => {
    setToppings(
      toppings.map((topping, currentIndex) =>
        currentIndex === index ? { ...topping, checked: !topping.checked } : topping
      )
    );

    // or
    // setToppings([
    //   ...toppings.slice(0, index),
    //   { ...toppings[index], checked: !toppings[index].checked },
    //   ...toppings.slice(index + 1),
    // ]);  }

    return (
      <div className="App">
        {toppings.map((topping, index) => (
          <Checkbox
            key={topping.name}
            isChecked={topping.checked}
            checkHandler={() => updateCheckStatus(index)}
            label={topping.name}
            index={index}
          />
        ))}
        <p>
          <pre>{JSON.stringify(toppings, null, 2)}</pre>
        </p>
      </div>
    );
  };
}
export default App;

```

Here we are storing the check status of the checkbox in the local state `toppings`. We have written a method `updateCheckStatus`, which will be called with the index of the changed checkbox and will update the local state. We are also displaying the current state in the JSON format so that we can verify everything is working as expected.

## Select All and Unselect All

We can implement select all and unselect all by simply updating all the checked statuses to true and false respectively.

App.js

```jsx
import { useState } from "react";

const allToppings = [
  { name: "Golden Corn", checked: false },
  { name: "Paneer", checked: false },
  { name: "Tomato", checked: false },
  { name: "Mushroom", checked: false },
  { name: "Onion", checked: false },
  { name: "Black Olives", checked: false },
];
export const Checkbox = ({ isChecked, label, checkHandler, index }) => {
  console.log({ isChecked });
  return (
    <div>
      <input type="checkbox" id={`checkbox-${index}`} checked={isChecked} onChange={checkHandler} />
      <label htmlFor={`checkbox-${index}`}>{label}</label>
    </div>
  );
};
function App() {
  const [toppings, setToppings] = useState(allToppings);
  const updateCheckStatus = (index) => {
    setToppings(
      toppings.map((topping, currentIndex) =>
        currentIndex === index ? { ...topping, checked: !topping.checked } : topping
      )
    );

    // or
    // setToppings([
    //   ...toppings.slice(0, index),
    //   { ...toppings[index], checked: !toppings[index].checked },
    //   ...toppings.slice(index + 1),
    // ]);  }

    const selectAll = () => {
      setToppings(toppings.map((topping) => ({ ...topping, checked: true })));
    };
    const unSelectAll = () => {
      setToppings(toppings.map((topping) => ({ ...topping, checked: false })));
    };
    return (
      <div className="App">
        <p>
          <button onClick={selectAll}>Select All</button>
          <button onClick={unSelectAll}>Unselect All</button>
        </p>
        {toppings.map((topping, index) => (
          <Checkbox
            key={topping.name}
            isChecked={topping.checked}
            checkHandler={() => updateCheckStatus(index)}
            label={topping.name}
            index={index}
          />
        ))}
        <p>
          <pre>{JSON.stringify(toppings, null, 2)}</pre>
        </p>
      </div>
    );
  };
}
export default App;

```

technology

Posts