What is JavaScript ? How is JS Code executed line by line?

Harshita Gupta — Sat, 17 Jun 2023 11:53:40 +0000

According to MDN Docs, a high level definition of JavaScript is:

JavaScript is a scripting or programming language that allows you to implement complex features on web pages.

Everything in JavaScript happens inside Execution Context. All the JavaScript code is executed inside it.

The execution context is a big box that contains two components:

Memory Component/Variable Environment
Code Component/Thread of Execution

Memory Component: Here all the variables and functions are stored as key-value pairs.

Code Component: Here whole JS code is executed one line at a time.

The above explanation makes us reach to this definition:
JavaScript is a Synchronous Single-Threaded language

Let's break down the above definition by understanding these keywords:
Synchronous: In a specific order
Single-threaded: JavaScript can execute one command at a time.
It can only go to the next line once the current line has been finished executing.

Now let us understand how the execution context is created with the help of JavaScript program.

var n = 2
function square(num){
    var ans = num * num
    return ans
}
var square2 = square(n)
var square4 = square(4)

When we run this whole code, a global execution context(GEC) is created. GEC is created in two phases:

Memory Creation Phase
Code Execution Phase

Memory Creation Phase
In this phase JavaScript will allocate memory to all the variables and functions.
Memory allocation starts from line 1 and goes till line 7 of the above code.

As JS encounters line 1 it allocates memory to n. It stores a special value as undefined.
It then see a function named square and allocation memory to variable square. Here it stores the whole code of the function inside this memory space.
Similary it will allocate memory to square2 and square4 as undefined.

Memory Component	Code Component
n: `undefined`
square: (num){ var ans = num * num return ans }
square2: `undefined`
square4: `undefined`

Code Execution Phase
The code again runs from line 1 to 7 after the memory allocation phase is finished.

JS encounters line 1 and replaces n's value from undefined to 2
Now from line 2 to 5 there is nothing to execute so it moves to line 6
At line number 6 function is invoked, since function is a new mini program in itself so a new Execution Context is created.
New execution context again has memory component and code component.
1. Memory Allocation Phase
  1. It allocates memory to num: undefined
  2. It allocates memory to ans: undefined
  3. No more functions or variables so memory allocation phase is completed.
  Memory Component Code Component
  
  num: undefined
  
  ans: undefined
2. Code Execution Phase
  1. When function is invoked with argument n then in line 1 n=2 which is passed as parameter to the function
  2. In the next line num * num is calculated inside code component and put inside ans in memory component.
  3. Now it sees return ans. When JS encounters return it returns the control back to the execution context where the function was invoked.
  4. Now the control goes line 6 again.
  5. The whole execution context for this instance of square function will now be deleted.
Now the square2 variable's undefined will be replaced with 4 (retuned as ans)
Similary function will be invoked on line 7 and pass 4 as argument which will return 16 (with all the above steps repeating in the same order).

Memory Component	Code Component
num: `undefined`
ans: `undefined`

Now JS is done with executing the whole code, now the whole Global execution context is deleted.
This is how JavaScript code is executed line by line.

Thanks!

Changing tab-index with DOM Manipulation in React

Harshita Gupta — Wed, 14 Jun 2023 18:30:47 +0000

Before we go through the DOM manipulation, let us understand

What is DOM?
The Document Object Model (DOM) is the data representation of the objects that comprise the structure and content of a document on the web.
It is a programming interface for web documents. It represents the page so that programs can change the document structure, style, and content. The DOM represents the document as nodes and objects; that way, programming languages can interact with the page.

Now let us understand Why need to change the tab-index?

Example: Let us consider we have a Material UI DataGrid component

As per WCAG guidelines, the table and its rows are generally not keyboard focusable because they're not interactive elements.

In the Material UI DataGrid component, first header column by default is keyboard focusable.

In such scenarios we might need to explicitly change the tabIndex to -1 in order to change the make the application meets the accessibility criteria.

You can better understand it with the following code:

import { useEffect } from "react";
import { DataGrid } from "@mui/x-data-grid";

First fetch the elements using document.querySelector() of which we need to change the tab-index.
document.querySelector() returns HTMLCollection as we have more than 1 element with class legend-color.
Store this HTMLCollection in a variable named headerCell.
Finally, we loop through headerCell, thus assigning tabIndex = -1 to each header cell which needs to be non-focusable.

If you wonder why we use setTimeout() then let me answer that for you. It may be possible that DOM might not have already loaded by the time script run. Thus, setTimeout() will ensure that once all the code is executed then we change the tabIndex.

const CustomDataGrid = () => {

useEffect(() => {
    setTimeout(() => {
        const headerCell = document.querySelector('legend-color')
        for(let i = 0; i < headerCell.length; i ++){
            headerCell[i].tabIndex = -1
        }
    }, 1000)
  }, [])

const columns = [
    {
        field: "id",
        headerName: "ID",
        headerClassName: "header-id"
    },
    {
        field: "firstName",
        headerName: "First name",
        headerClassName: "header-first-name"
    },
    {
        field: "lastName",
        headerName: "Last Name",
        headerClassName: "header-last-name"
    }
]
const rows = [
  { id: 1, firstName: "Harshita", lastName: "Gupta" },
  { id: 2, firstName: "Lannister", lastName: "Cersei" },
];

return (
<DataGrid 
    columns={columns}
    rows={rows}
  />
 )
}

Final results
Focus is removed from the first header column ID

Refer to the following sandbox for the code and implementation:
https://hctxgc.csb.app/

Hope this blog helped you.
Thanks 👩‍💻

DEV Community: Harshita Gupta

What is JavaScript ? How is JS Code executed line by line?

Changing tab-index with DOM Manipulation in React