DEV Community: Furkan Emin Can

Variable Declaration in JavaScript: A Comprehensive Guide

Furkan Emin Can — Fri, 11 Aug 2023 04:56:54 +0000

Declaring variables is what we do most in JavaScript. Knowing the inside of the variable declaration process gives you more idea about it. For example, if you are new to JavaScript, the behavior of var statement likely to be confusing for you.

Through this article, you will learn how to declare, and mutate variables using var, let, and const statements, and have a better understanding of the differences between them.

I will explain each concept in two parts:

Before ES6 (var statement)
After ES6 (let and const statements)

Let's dive into these statements:

Declaring Variables with Hoisting in Mind

When you declare variables in your app, the interpreter moves them to the top of their scope and allocates places in the memory before the execution starts. This process is called Hoisting.

1. Variable declaration with `var` statement:

When you declare a variable with var statement, it is initialized in the memory as undefined before the code execution. So, you can use the variable before declaring it, but it returns undefined.

When execution starts and reaches the line that the variable is declared, replaces the value in the memory with the value of the variable.

console.log(strawberry); // undefined

var strawberry = '🍓';

console.log(strawberry); // 🍓

With this behavior, the program runs without errors. However, in some cases, this can lead to unexpected results.

2. Variable declaration with `let` and `const` statements:

When you declare a variable with let or const statements the variable is allocated in the memory as uninitialized in the temporal dead zone. You cannot use variables in the temporal dead zone before their declaration. So, if you try to use a variable before declaring it, the program returns an error.

When the program reaches the line where the variable is declared, it initializes the variable with that value.

console.log(cherry); // ReferenceError

const cherry = "🍒";

console.log(cherry); // 🍒

If you try to run this code snippet, you will see an error similar to below. Because we try to access a variable in the temporal dead zone.

Understanding Variable Scopes

In JavaScript:

Everything between curly braces is block scope,

Everything inside a function is function scope.

1. Scope of `var` statement

Variables declared with var statement are available globally. (If they are not declared in a function.) So, you can use the variables declared inner scope is in outer scopes and vice-versa:

// Global Scope
var carrot = "🥕";

// Inner Scope
{
  console.log(carrot); // 🥕

  console.log(tomato); // undefined

  // More Inner Scope
  {
    console.log(carrot); // 🥕

    var tomato = "🍅";
  }

  console.log(tomato); // 🍅
}

As you can see from the code snippet:

We were able to use the carrot variable declared in the most outer (global) scope in the inner scopes.
We were able to use tomato variable declared in the inner scope in the outer scopes.

❗ Variables declared with var statement in a function are only available in the function scope, and cannot be used outside of it.

// Function Scope
function declareMelon() {
  var watermelon = "🍉";
}

console.log(watermelon); // ReferenceError

2. Scope of `let` and `const` statements:

The variables declared with let and const statements are only available in block scope.

const banana = "🍌";

// Block Scope
{
  console.log(banana); // 🍌

  let lemon = "🍋";

  // Inner Block Scope
  {
    console.log(banana); // 🍌
    console.log(lemon); // 🍋
  }
}

console.log(lemon); // ReferenceError

As you can see in the last line, you cannot use a variable created in the inner scope in the outer scopes.

Mutating Variables

This time the parts will change, the first group involves var and let statements and the second involves const statement. Because var and let statements are mutable, and const statement is immutable.

1. Mutation in `var` and `let` statements.

As I said var and let statements are mutable, so you can assign new values to the variables declared with them.

var pepper = "🌶️";
let apple = "🍏";

pepper = "🫑";
apple = "🍎";

console.log(pepper); // 🫑
console.log(apple); // 🍎

Additionally, you can mutate a variable from inner scopes:

For let statement, the variable will change in the scope where the declaration is made.
For var statement, the variable will change globally. (or in functional scope.)

{
  pepper = "🌶️";
  apple = "🍏";

  console.log(pepper); // 🌶️
  console.log(apple); // 🍏
}

console.log(pepper); // 🌶️
console.log(apple); // 🍏

2. Mutation in `const` statement

Variables declared with const statement are immutable. So you cannot re-assign them.

const strawberry = "🍓";

strawberry = "🍉"; // TypeError

If you try to run the code snippet above, the program throws an error similar to below:

❗Important Note: You cannot mutate arrays and objects via assignment but can mutate them via their methods, and property assignment.

const fruitsArray = ["🍎", "🍐"];
const fruitsObject = {
  apple: "🍎",
  pear: "🍐",
};

fruitsArray[2] = "🍒"; // [ '🍎', '🍐', '🍒' ]
fruitsArray.push("🍌"); // [ '🍎', '🍐', '🍒', '🍌' ]

fruitsObject.cherry = "🍒"; // { apple: '🍎', pear: '🍐', cherry: '🍒' }

Redeclaring Variables

Strangely, we can redeclare variables declared with var statement using the same name. This is another error-prone characteristic of var statement. Fortunately, this behavior has changed with let and const statements.

1. Redeclaration with `var` statement:

You can redeclare a variable declared with var statement in the same scope or inner-outer scopes.

As I said before, variables declared with var statement are global, so if you even redeclare a variable in the inner scope (again, except for functional scopes), the variable will change in all scopes.

var pepper = "🌶️";

console.log(pepper); // 🌶️

// Inner Scope
{
  var pepper = "🥦";

  console.log(pepper); // 🥦
}

console.log(pepper); // 🥦

As you can see in the code snippet, This behavior tends to cause big problems. Because someone working in the same codebase, unintentionally may declare a variable using the same name used before.

2. Redeclaration with `let` and `const` statements:

You cannot redeclare variables declared with let or const statements in the same scope. If you try the program throws an error.

let eggplant = "🍆";

let eggplant = "🥔"; // SyntaxError

But you can redeclare the variables in inner scopes. Because, as I said before, the variables declared with let and const statements are block scope and don't affect the outer scopes.

const carrot = "🥕";

// Block Scope
{
  const carrot = "🍒";

  console.log(carrot); // 🍒
}

console.log(carrot); // 🥕

Conclusion

Today ES6 statements are the default choice for variable declaration in JavaScript. Nevertheless, the var statement might still be encountered, especially in older apps. In this guide, you have learned the differences between var, let, and const statements, hoisting and scope in variable declaration.

Thank you for taking the time to read this article. If you have any questions, or thoughts feel free to comment.

See you in the next one!

Stay in Touch

Resources

JavaScript Visualized: Hoisting by Lydia Hallie
JavaScript Visualized: Scope (Chain) by Lydia Hallie
Hoisting by MDN Web Docs

How to Setup React App with Parcel and TypeScript

Furkan Emin Can — Mon, 29 May 2023 03:06:04 +0000

Parcel is a zero-config build tool with great out-of-the-box development experience and scalable architecture.

I experimented with Parcel in my previous project and I am happy with the result. (The second project of the Front End Development Libraries Curriculum of FreeCodeCamp.)

The setup process was a bit difficult. Thus, I will guide you to simplify this process in this article.

Note: To access the completed boilerplate, you can visit the react-parcel-ts-boilerplate.

1. Installing Dependencies

I have used npm for this boilerplate. But feel free to use any package manager you choose.

First, you need to install react and react-dom as dependencies.

npm i react react-dom

Next, you need parcel and typescript packages as development dependencies, also since this is a TypeScript project, you need type definitions for react and react-dom.

npm i -D parcel typescript @types/react @types/react-dom

2. Configuring `tsconfig.json`

The documentation says that:

Parcel supports TypeScript out of the box without any additional configuration.

When you try to run or build the app there is no problem. Yet, I consistently encountered TypeScript errors with IntelliSense.

In order to address these issues, I recommend using the following tsconfig.json file, as this configuration helped me resolve those issues:

{
  "compilerOptions": {
    "module": "ESNext",
    "target": "ESNext",
    "moduleResolution": "node",
    "lib": ["DOM", "ESNext"],
    "jsx": "react-jsx"
  }
}

3. Creating Base Files

You need to create these three files in the src directory:

1. App.tsx: This file serves as the root component of the app.

const App = () => <div>App</div>;

export { App };

2. index.tsx: This file is responsible for rendering the App component into the <div id="app"> element on the page.

import { createRoot } from 'react-dom/client';
import { App } from './App';

const root = createRoot(document.getElementById('app') as HTMLElement);

root.render(<App />);

3. index.html: This file serves as the entry point for the app.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>React (Parcel + TypeScript)</title>
  </head>
  <body>
    <div id="app"></div>
    <script type="module" src="index.tsx"></script>
  </body>
</html>

4. Configuring `package.json`

Make sure to add the source property in the package.json (No need for the main property.), and set its value as the path to the index.html file.

"source": "src/index.html"

Additionally, in order to run the app using scripts, you need to add the necessary scripts to the package.json file.

"scripts": {
  "start": "parcel",
  "build": "parcel build"
}

5. Running the App

Since the app is ready, you can run it with start script:

npm start

The "failed to install modules" Error

You may come across the following error, which I encountered when using pnpm in my previous project:

To resolve this issue, add the process property under the alias property in the package.json file and set its value to false.

"alias": {
  "process": false
}

Conclusion

Developing a React project with Parcel and TypeScript can present challenges, particularly on the TypeScript side. However, using this boilerplate was beneficial in my previous project, and I believe it can assist you as well.

Thank you for reading. Feel free to share your thoughts about Parcel in the comments section.

See you in the next one!

Stay in Touch

Resources

Parcel Documentation

How to Use SWR for Better Data Fetching Approach

Furkan Emin Can — Mon, 22 May 2023 04:51:30 +0000

In React, external data is very important to make your project more dynamic. However, when you use useEffect for data fetching, it is generally hard to manage the state, fortunately SWR simplifies this process.

Introduction to SWR

The first thing I want to say is what SWR means.

According to its documentation:

The name “SWR” is derived from stale-while-revalidate, a HTTP cache invalidation strategy popularized by HTTP RFC 5861. SWR is a strategy to first return the data from cache (stale), then send the fetch request (revalidate), and finally come with the up-to-date data.

So, SWR is a library that provides React hooks for data fetching.

Implementing SWR in Your Project: My Experience

I recently completed the first project for the Front End Libraries Certification of FreeCodeCamp. I tried SWR in this project and will share my experience.

Note: For more information, you can check the project's GitHub repository and CodeSandbox.

I used TypeScript for this project, but I will give you examples with JavaScript. So, don't worry if you don't know TypeScript. (I highly recommend it if you don't know.)

1. Creating `fetcher` function

I was planning to use Axios for the requests, so I created the async function below.

const fetcher = async (url) => {
  const { data } = await axios.get(url);

  return data;
};

This function is just a wrapper for the get method of Axios. It accepts a url parameter and returns data.

2. Creating a hook that fetches a random quote

Based on the section Make It Reusable in SWR documentation, I created a hook called useRandomQuote.

Note: In this project, I used Quotable API for random quotes.

This hook is a wrapper for useSWR hook.

In my case, the API returns an array with one element which is the random quote. Since data is undefined during the request, I used optional chaining.

And, the hook returns an object that contains the quote variable with the variables destructured from useSWR hook.

Let's check the code and inspect it:

import useSWR from 'swr/immutable';

const useRandomQuote = () => {
  const { data, ...restSWR } = useSWR(
    'https://api.quotable.io/quotes/random',
    fetcher
  );

  return {
    ...restSWR,
    quote: data?.[0],
  };
};

export { useRandomQuote };

In your projects, you almost always use useSWR hook.

Take a closer look at the useSWR hook:

const { data, error, isValidating, isLoading, mutate} = useSWR(
  key,
  fetcher
);

Firstly we imported useSWR hook.
Then we used it in our custom hook with two parameters: key and fetcher.

key is a unique string for the request which is like an id.

fetcher is an async function that accepts key and returns data.
Finally, it returns data, error, isValidating, isLoading, and mutate variables.

data is the variable returned from fetcher. During the first request, it will be undefined.

error is the error thrown by fetcher. If there is no error, it will be undefined.

isValidating is a boolean that indicates the request's status. It is true during each request including the first request.

isLoading also is a boolean that indicates the first request's status. It is true during the first request, then it will always be false.

mutate is a function that is used to modify the data manually.

If you noticed, I imported useSWR hook from swr/immutable in the first code snippet. It simply disables SWR's auto-revalidation. I prefer to use it because I want to revalidate the data manually with mutate function.

Understanding Auto-Revalidation

If the data you used is stale, SWR revalidates the data (re-fetches from the server) to keep freshness.

By default, SWR automatically revalidates the data (It assumes that the data is stale) in three cases:

Every time the component is mounted, even if there is data in the cache, it revalidates.
It revalidates when the window gets focused.
It revalidates when the browser regains its network connection.

3. Mutating the Data

If you want manually revalidate the data, you can use mutate function.

I have QuoteCard component that displays the current quote. This component has a New Quote button that handles the mutation of the quote.

const QuoteCard = () => {
  const { quote, isValidating, mutate } = useRandomQuote();

  return (
    {/* ... */}
    <button
      // ...
      onClick={() => mutate()}
    >
      New Quote
    </button>
    {/* ... */}
  )
}

When the mutate function is called, SWR revalidates the data. During this process, the quote variable remains the same (will not be undefined), and the isValidating variable becomes true.

Here is a diagram of this process:

4. Handling Concurrent Requests

If you don't handle request cancellation manually, the ongoing request continues even if the user initiates a new request alongside it, resulting in multiple concurrent requests.

SWR only updates the data after the last request is completed. If there are concurrent requests, their responses aren't important except for the last one. So if you don't cancel these requests, it results in unnecessary network usage.

I faced the same issue in my project. When the user clicks the New Quote button while a request is still loading, the application triggers a new request alongside the existing one.

Although I checked SWR's documentation, I couldn't find a built-in solution for this issue. (I also checked React Query, and it has a built-in solution for that. I am planning to experiment with it in my next project involving API usage.)

In this scenario, I could use AbortController to handle request cancellation, but I didn't use it to keep things simple. I just disabled the New Quote button during validation.

Conclusion

SWR helped me a lot in this project. If you have not used it previously, I highly recommend trying it in your future projects.

This is my first blog post, and I will be waiting for your feedback and thoughts about the library in the comments.

Stay in Touch

Resources

SWR Documentation
Revalidating options of SWR by Toru Kobayashi
My inspiration to use this library comes from this video by CoderOne. (I know this video is about React Query, but I wanted to try SWR first.)

DEV Community: Furkan Emin Can

Variable Declaration in JavaScript: A Comprehensive Guide

Declaring Variables with Hoisting in Mind

1. Variable declaration with var statement:

2. Variable declaration with let and const statements:

Understanding Variable Scopes

1. Scope of var statement

2. Scope of let and const statements:

Mutating Variables

1. Mutation in var and let statements.

2. Mutation in const statement

Redeclaring Variables

1. Redeclaration with var statement:

2. Redeclaration with let and const statements:

Conclusion

Stay in Touch

Resources

How to Setup React App with Parcel and TypeScript

1. Installing Dependencies

2. Configuring tsconfig.json

3. Creating Base Files

4. Configuring package.json

5. Running the App

The "failed to install modules" Error

Conclusion

Stay in Touch

Resources

How to Use SWR for Better Data Fetching Approach

Introduction to SWR

Implementing SWR in Your Project: My Experience

1. Creating fetcher function

2. Creating a hook that fetches a random quote

Understanding Auto-Revalidation

3. Mutating the Data

4. Handling Concurrent Requests

Conclusion

Stay in Touch

Resources

1. Variable declaration with `var` statement:

2. Variable declaration with `let` and `const` statements:

1. Scope of `var` statement

2. Scope of `let` and `const` statements:

1. Mutation in `var` and `let` statements.

2. Mutation in `const` statement

1. Redeclaration with `var` statement:

2. Redeclaration with `let` and `const` statements:

2. Configuring `tsconfig.json`

4. Configuring `package.json`

1. Creating `fetcher` function