Posts

Showing posts with the label Hoisting

SOLID / DRY principles

-
In software development, Object-Oriented Design plays a crucial role when it comes to writing flexible, scalable, maintainable, and reusable code. There are so many benefits of using OOD but every developer should also have the knowledge of the SOLID principle for good object-oriented design in programming. The SOLID principles are designed to help developers design robust, maintainable applications. The five SOLID principles are: Single-responsibility principle - Function and classes should have one job. Open–closed principle - Classes and functions should be open for  extension but not for modification. Liskov substitution principle - Child class can replace parent class Interface segregation principle - This principle is the first principle that applies to Interfaces instead of classes in SOLID and it is similar to the single responsibility principle. It states that “do not force any client to implement an interface which is irrelevant to them“. Here your main goal is ...
Post a Comment
Read more

Hoisting in Javascript

-
"Java script putting function declarations into memory before it executes any code segment is that it allows you to use a function before you declare it in your code Hoisting is a JavaScript mechanism where variables and function declarations are moved to the top of their scope before code execution. T his means that no matter where functions and variables are declared, they are moved to the top of their scope regardless of whether their scope is global or local Note : JavaScript only hoists declarations, not initialization . If a variable is declared and initialized after using it, the value will be undefined. Ex :  num = 100; // Initialization console.log(name) // 100 var  num; //  Declaration   console.log(name)  // Undefined var  num = 100; //  Declaration   Here only declaration will go on the top not initialization. let Vs var The main difference between  let  and  var  is that scope of a variable defined with  let ...
Post a Comment
Read more

Popular posts from this blog

Why do we need callbacks

-
In JavaScript, callbacks are commonly used due to the language's asynchronous nature and event-driven programming model. Here are some specific reasons why callbacks are important in JavaScript: 1. Asynchronous Operations: JavaScript often handles operations that take time to complete, such as making AJAX requests, fetching data from APIs, or reading files. Callbacks allow you to specify what should happen once these operations are finished. By passing a callback function as an argument, you can define the behavior that should occur once the asynchronous operation completes, ensuring that the code doesn't block while waiting for a response. 2. Event Handling: JavaScript is extensively used for building interactive web applications that respond to user actions, such as button clicks, form submissions, or mouse movements. Callbacks are employed to handle these events by attaching callback functions to event listeners. When an event occurs, the associated callback function is exec...
Read more

Difference between localStorage and sessionStorage

-
Both `localStorage` and `sessionStorage` are web storage options provided by modern web browsers to store data on the client-side. They have some similarities but also important differences in terms of data persistence and scope. Here's a breakdown of the key differences: 1. Data Persistence:    - `localStorage`: The data stored in `localStorage` persists even after the browser window is closed and reopened. It remains available until explicitly cleared or removed.    - `sessionStorage`: The data stored in `sessionStorage` persists only for the duration of the current browser session. When the browser window or tab is closed, the data is cleared and no longer accessible. 2. Scope:    - `localStorage`: The data stored in `localStorage` is accessible across multiple windows or tabs of the same origin. This means that data set in one window/tab can be accessed in another window/tab of the same origin.    - `sessionStorage`: The data stored in `sessio...
Read more

Scope in javascript

-
In JavaScript, scope refers to the visibility and accessibility of variables, functions, and objects in a particular part of your code. It determines where and how variables can be accessed and modified. There are two main types of scope in JavaScript: global scope and local scope. 1. Global Scope:    - Variables declared outside of any function have global scope.    - Global variables can be accessed from anywhere in your code, including inside functions.    - Example:    var globalVariable = "I'm a global variable";    function printGlobal() {      console.log(globalVariable);    }    printGlobal(); // Output: I'm a global variable 2. Local Scope:    - Variables declared within a function have local scope, meaning they are only accessible within that function (including any nested functions).    - Local variables take precedence over global variables with the same name.   ...
Read more