Forem: Tanvir Ahmed

JavaScript Nullish Coalescing Operator (??)

Tanvir Ahmed — Sat, 01 Nov 2025 05:03:24 +0000

Nullish Coalescing Operator (??) হলো JavaScript-এর একটি আধুনিক লজিক্যাল অপারেটর, যা কোনো ভ্যারিয়েবলের মান null বা undefined হলে একটি default (বিকল্প) মান ব্যবহার করতে সাহায্য করে।

syntax

let result = value1 ?? value2;

ব্যাখ্যা:

যদি value1 null বা undefined না হয়, তাহলে value1 রিটার্ন করবে।
যদি value1 null বা undefined হয়, তাহলে value2 রিটার্ন করবে।

let name = null;
let finalName = name ?? "Guest";

console.log(finalName); // Output: "Guest"

এখানে name এর মান null, তাই ?? অপারেটর "Guest" রিটার্ন করেছে।

let name = "Tanvir";
let finalName = name ?? "Guest";

console.log(finalName); // Output: "Tanvir"

যেহেতু name-এর মান আছে, তাই fallback "Guest" ব্যবহৃত হয়নি।

Undefined এর ক্ষেত্রে

let age;
let defaultAge = 18;

let finalAge = age ?? defaultAge;

console.log(finalAge); // Output: 18

age undefined, তাই defaultAge (১৮) রিটার্ন হয়েছে।

Node.js Stream এবং Buffer

Tanvir Ahmed — Wed, 29 Oct 2025 00:02:55 +0000

💻 Node.js: Buffer (বাফার)

Buffer হলো Node.js-এর একটি বিল্ট-ইন ক্লাস যা বাইনারি ডেটা পরিচালনার জন্য ব্যবহৃত হয়। JavaScript সাধারণত স্ট্রিং এবং অবজেক্ট নিয়ে কাজ করে, কিন্তু ফাইল, নেটওয়ার্ক ডেটা বা অন্যান্য বাইনারি ডেটা প্রক্রিয়াকরণের জন্য Buffer ব্যবহার করা হয়। Buffer হলো একটি ফিক্সড-সাইজের মেমরি ব্লক যা বাইনারি ডেটা স্টোর করে।

Buffer-এর মূল বৈশিষ্ট্য:

বাইনারি ডেটা সরাসরি ম্যানিপুলেট করার জন্য ব্যবহৃত হয়।
এটি ArrayBuffer-এর মতো কিন্তু আরও ফ্লেক্সিবল এবং Node.js-এর জন্য অপটিমাইজড।
কোনো এনকোডিং ছাড়াই কাঁচা (raw) ডেটা স্টোর করতে পারে।


const buf = Buffer.from('Hello', 'utf8');

console.log(buf);
// আউটপুট: <Buffer 48 65 6c 6c 6f>

console.log(buf.toString());
// আউটপুট: Hello

💻 Node.js: Stream (স্ট্রীম)

Stream হলো Node.js-এর একটি শক্তিশালী ফিচার যা ডেটাকে ছোট ছোট অংশে (chunks) প্রক্রিয়া করতে দেয়। এটি বড় ফাইল বা নেটওয়ার্ক ডেটা পরিচালনার জন্য উপযোগী, কারণ পুরো ডেটা একসাথে মেমরিতে লোড করার প্রয়োজন হয় না।

Stream-এর প্রকারভেদ:

Readable Stream: ডেটা পড়ার জন্য (যেমন: ফাইল থেকে পড়া, HTTP রিকোয়েস্ট থেকে ডেটা পড়া)।
Writable Stream: ডেটা লেখার জন্য (যেমন: ফাইলে লেখা, HTTP রেসপন্সে লেখা)।
Duplex Stream: পড়া এবং লেখা উভয়ই সম্ভব (যেমন: TCP সকেট)।
Transform Stream: ডেটা পড়া এবং লেখার সময় মডিফাই করা যায় (যেমন: কম্প্রেশন)।

Stream-এর সুবিধা:

মেমরি দক্ষতা: বড় ফাইল বা ডেটা প্রক্রিয়াকরণে কম মেমরি ব্যবহার করে।
দ্রুততা: ডেটা চাঙ্কে প্রক্রিয়া হওয়ায় অপেক্ষার সময় কমে।
পাইপলাইন: এক স্ট্রিম থেকে আরেক স্ট্রিমে ডেটা পাঠানো সহজ।

Readable Stream উদাহরণ:

const fs = require('fs');

// Readable Stream তৈরি
const readStream = fs.createReadStream('input.txt', { encoding: 'utf8' });

// ডেটা পড়া
readStream.on('data', (chunk) => {
  console.log('নতুন চাঙ্ক পাওয়া গেছে:');
  console.log(chunk);
});

// স্ট্রিম শেষ হলে
readStream.on('end', () => {
  console.log('ডেটা পড়া শেষ।');
});

// ত্রুটি হ্যান্ডলিং
readStream.on('error', (err) => {
  console.error('ত্রুটি:', err);
});

Writable Stream উদাহরণ:

const fs = require('fs');

// Writable Stream তৈরি
const writeStream = fs.createWriteStream('output.txt');

// স্ট্রিমে ডেটা লেখা
writeStream.write('এটি একটি টেস্ট ডেটা।\n', 'utf8');
writeStream.write('আরেকটি লাইন।\n', 'utf8');

// স্ট্রিম বন্ধ করা
writeStream.end();

// লেখা শেষ হলে
writeStream.on('finish', () => {
  console.log('ডেটা লেখা শেষ।');
});

// ত্রুটি হ্যান্ডলিং
writeStream.on('error', (err) => {
  console.error('ত্রুটি:', err);
});

পাইপিং (Piping) উদাহরণ:
পাইপিং হলো একটি Readable Stream থেকে ডেটা সরাসরি Writable Stream-এ পাঠানোর প্রক্রিয়া।

const fs = require('fs');

const readStream = fs.createReadStream('input.txt');
const writeStream = fs.createWriteStream('output.txt');

// পাইপিং
readStream.pipe(writeStream);

console.log('ডেটা পাইপ করা হয়েছে।');

Transform Stream উদাহরণ:
Transform Stream ডেটাকে মডিফাই করে। নিচে একটি উদাহরণ দেওয়া হলো যেখানে ডেটাকে বড় হাতের অক্ষরে রূপান্তর করা হচ্ছে।

const { Transform } = require('stream');

const upperCaseTransform = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

process.stdin.pipe(upperCaseTransform).pipe(process.stdout);

💻 উপসংহার

Node.js-এ Buffer এবং Stream হলো শক্তিশালী টুল যা বাইনারি ডেটা এবং বড় ডেটা সেট পরিচালনার জন্য ব্যবহৃত হয়। Buffer ব্যবহার করা হয় ছোট ডেটা ম্যানিপুলেশনের জন্য, আর Stream ব্যবহার করা হয় মেমরি-দক্ষ উপায়ে বড় ডেটা প্রক্রিয়াকরণের জন্য। এগুলো ব্যবহার করে ফাইল সিস্টেম, নেটওয়ার্কিং এবং ডেটা প্রসেসিংয়ে দক্ষতা বাড়ানো যায়।

Why NestJS is the Ideal Framework for Scaling Large JavaScript Projects

Tanvir Ahmed — Sun, 22 Jun 2025 06:42:42 +0000

A crucial choice in the constantly changing field of JavaScript development is which framework to use for large-scale projects. Let's introduce NestJS, a potent framework that is quickly taking the lead in creating dependable, scalable apps. We'll look at the reasons why NestJS is unique for creating intricate, enterprise-level applications in this post.

What is NestJS?

NestJS is an advanced framework for Node.js server-side application development. It is a fantastic choice for large-scale applications because it uses TypeScript and is greatly influenced by Angular. Because it can easily tackle enterprise-level difficulties, it has garnered a lot of popularity since Kamil Myśliwiec launched it in 2017.

Key Features for Scaling Large Projects

1.Modular Architecture
A project can be easily broken up into smaller, reusable, and self-contained components thanks to NestJS's encouragement of modular design. Teams can work separately on different project components without treading on each other's toes thanks to this modular approach, which aids in application scalability. Modules are simple to add, remove, or change as your project develops.

2.TypeScript Support
TypeScript support is built into NestJS by default, allowing your code to use static typing. Particularly when dealing with big teams, this translates into fewer runtime errors and a more stable, maintainable codebase. The interfaces and decorators provided by TypeScript also improve the organization and clarity of code.

3.Dependency Injection
The robust dependency injection mechanism in NestJS makes dependency management simple. In order to maintain the scalability and flexibility of your application, this solution helps decouple your services and streamlines testing and maintenance. During tests, it is simpler to simulate dependencies and inject services where necessary.

4.Built-in ORM Support
Complex data management is a major concern when developing huge apps. Popular Object-Relational Mapping (ORM) technologies like TypeORM and Sequelize are supported by NestJS, which facilitates seamless database connections. Advanced queries, relationships, and migrations are all built into NestJS and are crucial for effectively managing massive volumes of data.

5.Middleware and Interceptors
In large projects, resolving cross-cutting issues like error management, authentication, and logging can become difficult. This is made easier by NestJS's middleware and interceptors, which enable you to handle these issues in an organized manner. It's easy to handle exceptions, change responses, and manage the complete request-response cycle.

6.WebSocket and Microservices Support
NestJS is ideal for applications requiring distributed systems or real-time communication. WebSockets and microservices architectures are supported by default, making it ideal for applications requiring quick, low-latency communication, such as chat systems or Internet of Things platforms.

Benefits for Large Projects

Improved Maintainability:NestJS reduces technical debt by making it simpler to scale and maintain your code over time using its own modular structure and TypeScript's type safety.
Enhanced Collaboration:NestJS's modular design minimizes code overlap and enhances teamwork by enabling many developers to work on separate modules.
Performance Optimization:The non-blocking I/O mechanism of Node.js allows NestJS to guarantee great performance even as the project expands. The framework's effective architecture can easily manage higher traffic levels.
Extensibility:NestJS's functionality may be expanded without changing the core framework thanks to its support for custom decorators and plugins. As your project's needs change, you can incorporate additional functionality.

Challenges and Solutions

Learning Curve:NestJS has very powerful capabilities, however there is a learning curve. What's wrong? To catch up, go through the community lessons and documentation.
Overhead:It may feel more complicated to set up first than with simpler frameworks. However, the overhead is decreased by the ability to quickly build boilerplate code with NestJS's CLI.
Testing Complexity:It might be challenging to do the extensive testing needed for large projects. For thorough test coverage, you can combine NestJS with Jest, which fortunately has built-in testing facilities.

Conclusion

A notable framework for creating sizable, scalable JavaScript applications is NestJS. Enterprise-level projects benefit greatly from its modular design, TypeScript integration, and support for strong features like dependency injection, WebSocket connectivity, and microservices. NestJS provides you with the resources you need to be successful whether you're developing a complex commercial application, real-time system, or website with a lot of traffic.

TypeScript Data Types - Comprehensive Guide

Tanvir Ahmed — Sat, 14 Jun 2025 06:52:10 +0000

TypeScript provides a robust type system built on top of JavaScript, helping ensure the accuracy of your code's types. In this guide, we will explore both primitive and non-primitive data types in TypeScript, complete with explanations and examples.

❏ Primitive Data Types

Primitive data types are the most basic types in TypeScript, and they represent single values. These types are immutable, meaning their values cannot be changed once set. TypeScript supports the following primitive data types:

1️⃣ Any

The any type is a special type in TypeScript that allows you to store values of any type. It is used when you are unsure about the type of a variable.

let data: any;
data = "Hello, world!";   // string
data = 42;                // number
data = { key: "value" };  // object
data = [1, 2, 3];         // array

2️⃣ Number

The number type is used for numerical values, both integers and floating-point numbers.

let age: number = 25;
let price: number = 199.99;

3️⃣ String

The string type is used to represent text (sequences of characters).

let name: string = "John";
let greeting: string = "Hello, world!";

4️⃣ Boolean

The boolean type represents true or false values.

let isActive: boolean = true;
let isComplete: boolean = false;

5️⃣ undefined

The undefined type is used when a variable is declared but not assigned a value.

let notAssigned: undefined = undefined;

6️⃣ null

The null type is used to indicate that a variable has no value.

let emptyValue: null = null;

❏ Non-Primitive Data Types

Non-primitive data types in TypeScript (also called reference types) are used to store collections of values or more complex structures. Unlike primitive types, non-primitive types are mutable (can be changed), and they store references to the values in memory, not the actual values themselves.

1️⃣ Array Data Type

An array holds a collection of values of a specific type. TypeScript provides two ways to declare an array:

let numbers: number[] = [1, 2, 3, 4, 5];
let fruits: Array<string> = ['apple', 'banana', 'cherry'];

Array with Mixed Types:

let mixedArray: (number | string)[] = [1, 'apple', 2, 'banana'];

2️⃣ Object Data Type

An object in TypeScript is a collection of key-value pairs where each key is a string and each value can be of any type.

emample:01

const user = {
  firstName: "John",
  lastName: "Doe",
};

emample:02

const user2: {
  company: "Programming Here";
  firstName: string;
  middleName?: string;  // Optional property
  lastName: string;
  isMarried: boolean;
} = {
  company: "Programming Here",
  firstName: "Tanvir",
  lastName: "Soysov",
  isMarried: true,
};

3️⃣ Function Data Type

Functions in TypeScript can be typed by defining the types of parameters and return values.

Function Example:

function add(a: number, b: number): number {
  return a + b;
}

❏ Other Types

1️⃣ unknown Data Type

The unknown type in TypeScript is a type-safe version of any. When a variable's type is unknown, TypeScript enforces that you cannot perform operations on it until you explicitly check its type.

const handleData = (data: unknown) => {
    if (typeof data === 'string') {
        console.log("String length:", data.length);
    } else if (typeof data === 'number') {
        console.log("Number squared:", data * data);
    } else {
        console.log("Unknown type");
    }
};
handleData("hello");    // String length: 5
handleData(4);          // Number squared: 16

2️⃣ Nullable Data Type

A nullable type in TypeScript means that a variable can either have a value or be null or undefined.

const searchName = (value: string | null) => {
    if (value) {
        console.log("Searching for:", value);
    } else {
        console.log("There is nothing to search.");
    }
};

3️⃣ Never Data Type

The never type is used when a function never returns a value. This typically happens when a function throws an error or has an infinite loop.

const throwError = (message: string): never => {
    throw new Error(message);
};

Conclusion

TypeScript's type system enables developers to write safer and more robust code. By understanding and using both primitive and non-primitive data types, as well as special types like any, unknown, nullable, and never, you can harness the full power of TypeScript in your projects.

JavaScript Math Object Demystified

Tanvir Ahmed — Sun, 02 Mar 2025 08:18:22 +0000

The JavaScript Math object is a built-in object that provides mathematical functions and constants for performing complex calculations. It is static, meaning you do not need to create an instance of it to use its methods. Instead, you can directly call its properties and methods using Math.

❑ Math Constants (Predefined Values)
✔️Math.PI 3.141592653589793
✔️Math.E 2.718281828459045

Understanding JavaScript Data Types: A Comprehensive Guide to Primitive and Reference Types with Examples

Tanvir Ahmed — Tue, 31 Dec 2024 10:19:22 +0000

JavaScript has several built-in data types, which can be categorized into two broad groups:

🗹 Primitive Types

🗹 Non-Primitive (Reference) Types.

Aspect	Primitive Data Types	Reference Data Types
Examples	Number, String, Boolean	Object, Array, Function
Storage	Stack	Heap
Mutability	Immutable	Mutable
Value Type	Stored as value	Stored as reference
Passing in Function	Passed by value	Passed by reference
Type Checking	typeof	typeof, instanceof
Performance	Faster	Slower

Now,

⌬ Storage

➕ Primitive Data Types: Stored in the stack (fixed memory allocation)

let x = 10;
let y = x; // Copies the value
y = 20;
console.log(x); // 10 (original value remains unaffected)

➕ Reference Data Types: Stored in the heap (dynamic memory allocation).

let obj1 = { name: 'Alice' };
let obj2 = obj1; // Copies the reference, not the value
obj2.name = 'Bob';
console.log(obj1.name); // "Bob" (original value is affected)

⌬ Mutability

➕ Primitive Data Types: Immutable (cannot be changed after creation).

let str = "Hello";
str[0] = "h"; // No effect
console.log(str); // "Hello" (strings are immutable)

➕ Reference Data Types: Mutable (values can be changed).

let arr = [1, 2, 3];
arr[0] = 10;
console.log(arr); // [10, 2, 3]

⌬ Value vs Reference

➕ Primitive Data Types: Stored as values. Directly hold the data.

let a = 5;
let b = a;
b = 10;
console.log(a); // 5 (original value is unaffected)

➕ Reference Data Types: Stored as references to memory locations.

let objA = { key: 'value' };
let objB = objA;
objB.key = 'newValue';
console.log(objA.key); // "newValue" (both reference the same object)

JavaScript Data Types

Type	Examples
Primitive Types	➀ Number ➁ String ➂ Boolean ➃ Undefined ➄ Null
Non-Primitive Types	➀ Object ➁ Array ➂ Function

❐ Now write Primitive type with deatils

Primitive data types are immutable and stored by value.

✚ Number

let age = 25; // Integer
let pi = 3.14159; // Floating-point
let negativeNumber = -42; // Negative number
let exponential = 1.23e4; // 12300 in exponential notatio

✚ String

let singleQuote = 'Hello, world!';
let doubleQuote = "JavaScript is awesome!";
let templateLiteral = `This is a template literal`;

let multiLine = `This is a multi-line string.`;
console.log(`Name: ${singleQuote}, Length: ${singleQuote.length}`);

✚ Boolean
➭ Represents a logical value: true or false.

let isJavaScriptFun = true;
let isOver18 = false;

console.log(typeof isJavaScriptFun); // "boolean"
console.log(5 > 2); // true
console.log(10 === '10'); // false

✚ Undefined
➭ A variable is declared but not assigned a value.

let x;
console.log(x); // undefined
console.log(typeof x); // "undefined"

✚ Null
➭ Represents the intentional absence of any value (empty or unknown).

let y = null;
console.log(y); // null
console.log(typeof y); // "object" (this is a quirk in JavaScript)

❐ Now write Non-Primitive type with deatils

Non-primitive data types are mutable and stored by reference..

✚ Object

let person = {
  name: 'John',
  age: 30,
  isStudent: false,
  hobbies: ['reading', 'gaming'],
  address: {
    city: 'New York',
    zip: '10001',
  },
};

console.log(person.name); // "John"
console.log(person.address.city); // "New York"
console.log(typeof person); // "object"

✚ Array

let fruits = ['Apple', 'Banana', 'Cherry'];
let mixedArray = [1, 'Hello', true, null, undefined];

console.log(fruits[0]); // "Apple"
console.log(mixedArray.length); // 5
console.log(typeof fruits); // "object" (arrays are objects in JS)

✚ Function
➭ Represents a logical value: true or false.

function greet(name) {
  return `Hello, ${name}!`;
}

let sum = function(a, b) {
  return a + b;
};

let multiply = (x, y) => x * y;

console.log(greet('Alice')); // "Hello, Alice!"
console.log(sum(3, 4)); // 7
console.log(multiply(5, 6)); // 30
console.log(typeof greet); // "function"

🧷Ultimate Guide to Transforming Any Value into a String in JavaScript

Tanvir Ahmed — Sun, 29 Dec 2024 11:27:22 +0000

Converting values to strings is a fundamental task in JavaScript, useful for formatting, logging, or preparing data for display. This guide explores seven versatile methods to achieve this:

1️⃣ String(value) - A simple and reliable way to turn anything into a string, even null or undefined

2️⃣ toString() - Works for most values but gives an error if you try it on null or undefined.

3️⃣ Template Literals - Use backticks (${value}) to quickly and clearly turn a value into a string.

4️⃣ Concatenation (+ "") - Add an empty string to a value to change it into a string easily.

5️⃣ JSON.stringify() - Best for converting objects and arrays into a structured string format.

1️⃣ Using String()

The String() function is the most straightforward way to convert a value to a string. It works for all types of values, including null and undefined.

🚩Always works for any value

2️⃣ Using toString()

The .toString() method is available on most data types, including numbers, booleans, arrays, and objects. However, it cannot be used directly on null or undefined, which will throw an error.

3️⃣ Using Template Literals

Template literals (${value}) are an implicit way to convert values to strings. They use the default string conversion of the value, making it a clean and concise option.

4️⃣ Using + "" (Concatenation with Empty String)

By concatenating a value with an empty string, JavaScript implicitly converts the value to a string.

5️⃣ Using JSON.stringify()

JSON.stringify() converts values into a JSON-formatted string. This is particularly useful for arrays and objects where you want to maintain their structure in the string format.

🚀 Master the Most Powerful JavaScript String Methods (With Real-World Examples)

Tanvir Ahmed — Tue, 24 Dec 2024 07:40:16 +0000

Key Features of JavaScript String Methods

✅ Immutability: Strings in JavaScript are immutable, meaning their original value cannot be changed. String methods return a new string or value without altering the original string.

✅ Case Sensitivity: String methods are case-sensitive. For example, "Hello" and "hello" are treated as different strings.

✅ Chaining Methods: String methods can be chained together to perform multiple operations in a single line of code.

✅ Regular Expressions: Many string methods, such as match(), replace(), and split(), support regular expressions for advanced pattern matching and manipulation.

Now List String Method

No	Method
01	toUpperCase()
02	toLowerCase()
03	trim()
04	charAt()
05	split()
06	concat()
07	slice()
08	replace()
09	include()
10	repeat()
11	indexOf()
12	startWith() & endsWith()

1.toUpperCase():

The toUpperCase() method is used to convert all the alphabetic characters in a string to uppercase. Non-alphabetic characters, such as numbers, spaces, or symbols, remain unchanged.

syntax: string.toUpperCase();

2.toLowerCase():

The toLowerCase() method is used to convert all the alphabetic characters in a string to lowercase. Like toUpperCase(), non-alphabetic characters remain unchanged.

syntax: string.toLowerCase();

3.trim():

The trim() method in JavaScript is used to remove whitespace from both the beginning and the end of a string. Whitespace characters include spaces, tabs, and newline characters.

syntax: string.trim;

4.charAt():

The charAt() method in JavaScript is used to retrieve a character at a specific index in a string. It returns the character at the given position, or an empty string if the index is out of range.

syntax: string.charAt();

5.split():

The split() method in JavaScript is used to divide a string into an array of substrings based on a specified separator. It splits the string wherever the separator occurs and returns a new array with the resulting substrings.

syntax: string.split([separator[, limit]]);

6.concat():

The concat() method in JavaScript is used to merge two or more arrays or strings into a new array or string. It does not modify the original array or string, but instead returns a new one that contains the merged data.

string1.concat(string2, string3, ..., stringN);

7.slice():

The slice() method in JavaScript extracts a section of an array or string and returns it as a new array or string, without modifying the original array or string.

string.slice(start, end);

8.replace():

The replace() method in JavaScript allows you to replace parts of a string with another string. It works with both strings and regular expressions.

string.replace(pattern, replacement)

9.include():

The includes() method determines whether a string contains a specified substring, returning true or false based on the presence of the substring.

Features
i.Case-Sensitive: The includes() method is case-sensitive.
ii.Boolean Result: Returns a true or false.

string.includes(searchString, position)

10.repeat():

The repeat() method constructs and returns a new string, consisting of the specified number of copies of the original string, concatenated together.

string.repeat(count)

11.indexOf():

The indexOf() method in JavaScript is used to determine the first occurrence of a specified substring within a string. It returns the index of the first occurrence of the substring. If the substring is not found, it returns -1.

Return Value:
The index of the first occurrence of searchValue.-1 if searchValue is not found.

string.indexOf(searchValue, fromIndex)

12.startWith() & endsWith():

The startsWith() and endsWith() methods in JavaScript are used to check whether a string begins or ends with a specified substring. Both methods return a boolean (true or false).

string.startsWith(searchString, position) string.endsWith(searchString, length)

What is the difference between Null and undefined in JavaScript?

Tanvir Ahmed — Fri, 18 Oct 2024 16:56:44 +0000

Null

In JavaScript, null is a primitive value that represents the intentional absence of any object value. It is one of JavaScript's falsy values, meaning it evaluates to false in boolean contexts. However, it is distinct from undefined, which represents a variable that has been declared but has not been assigned a value.

null is a special primitive value, but when you check its type using typeof, it returns "object".

null is used when a variable is expected to hold an object but currently doesn't have one. It signals the intentional absence of a value.

let person = null;  // The `person` variable explicitly has no value.

Used when you intentionally want to signify "no value" or "empty."

Undefined

In JavaScript, undefined is a primitive value automatically assigned to variables that have been declared but not yet assigned a value.

undefined is a primitive type in JavaScript. It refers to variables that have been declared but not initialized, and its typeof will correctly reflect "undefined".

let x;
console.log(typeof x);         // "undefined"

Difference Between null and undefined

In this example, uninitializedVariable is undefined because it hasn't been assigned any value.
Meanwhile, objectWithNoValue is explicitly set to null, signaling that it should hold an object, but currently it doesn’t.

Comparison

Loose equality (==) null and undefined are loosely equal because they both represent an "empty" value.

console.log(null == undefined);  // true

Strict equality (===) They are not strictly equal because they are different types.

console.log(null == undefined);  // true

JavaScript Equals: JavaScript ‘===’ vs ‘==’Comparison Operator

Tanvir Ahmed — Thu, 17 Oct 2024 13:06:30 +0000

In JavaScript, the equality operators "==" and "===" are used to compare two values, but they work differently in terms of how they handle data types. Here’s a simple explanation:

1. == (Loose Equality):

The JavaScript equals or loose equality operator ( == ) checks if two variables or values are equal. It returns true if two values are of equal value, even if they're of different types. Conversely, it returns false if the values aren't of equal value.

Here, JavaScript converts the string '1' into a number 1 and then compares them, so it returns true.

What it does: It checks if two values are equal, but ignores the data type.
Type conversion (coercion): JavaScript automatically converts one or both values to the same type before comparing them.

Others Example:

i). 0 == false is true (because false is converted to 0)
ii). null == undefined is true (they are considered loosely equal)

Problem: This automatic type conversion can sometimes lead to unexpected results, so it’s generally considered less reliable.

2. === (Strict Equality):

The strict equality (===) operator checks whether its two operands are equal, returning a Boolean result. Unlike the equality operator, the strict equality operator always considers operands of different types to be different.

Here, JavaScript does not convert the string '1' into a number. Since 1 is a number and '1' is a string, it returns false.

What it does: It checks if two values are exactly equal, including both the value and the data type.
No Type conversion: It does not perform type conversion; the types must match for the comparison to return true.

Others Example:

i). 0 == false is false (because 0 is a number and false is a boolean)
ii). null == undefined is false (they are of different types)

Summary:

== (loose equality) compares values after converting them to the same type.
=== (strict equality) compares values without any type conversion.

Exploring the Core of true value vs false value in JavaScript...

Tanvir Ahmed — Thu, 17 Oct 2024 04:20:49 +0000

Truthy Value

In JavaScript, a truthy value is any value that is considered true when evaluated in a Boolean context. Values that are not falsy are considered truthy.

Example of truthy values:

Any non-zero number (1,-5,3.14)
Non-empty strings ("hello" )
space value(" ")
Objects ({}, [])
The boolean true

Now Example,

1.Checking a Non-empty String:

Explanation: The string "JavaScript" is a non-empty string, so it evaluates to true.

2.Checking a String with a Space:

Explanation: The string " " (a string containing a space) is also a non-empty string, which evaluates to true.

3.Checking a Positive Number:

Explanation: The number 100 is a non-zero number, so it evaluates to true.

4.Checking a Negative Number:

Explanation: The number -5 is also a non-zero number, making it truthy.

5.Checking an Empty Array & Object:

Explanation: An empty array [] is considered truthy in JavaScript.
Explanation: An empty object {} is also considered truthy

6.Checking the Boolean True:

Explanation: The boolean value true is, by definition, truthy.

Falsy Value

A falsy value is something which evaluates to FALSE, for instance when checking a variable.

Example of falsy values:

0 zero && (-0) negative zero
empty strings ("" )
null,undefine & Nan
The boolean false

Now Example,

Part01

Part02

JavaScript uses three dots (...) for both the rest and spread operators. But these two operators are not the same.

Tanvir Ahmed — Sat, 12 Oct 2024 17:15:30 +0000

Spread Operator:

The spread operator is used to break apart items in things like arrays, strings, or objects into individual pieces. It's often used to copy or join arrays, or to pass the items in an array as separate arguments to a function.

`# 1.0 Array`

1.1 Copy an array:
Instead of modifying the original array, you can create a shallow copy of an array.

1.2 Concatenating arrays:
Using the spread operator, you can concatenate arrays easily without using .concat().

1.3 Adding elements to an array:
You can easily add new elements to an array using the spread operator.

`# 2.0 Object`

2.1 Copy an object:

2.2 Merging object:
The spread operator allows you to merge two or more objects. If there are conflicting properties, the properties of the object that appears later will overwrite the previous ones.

`# 3.0 Function`

3.1 Using Spread in Function Calls :
You can use the spread operator to pass an array as individual arguments to a function.

Rest Operator:

The JavaScript Rest parameter allows a function to accept an indefinite number of arguments as an array. It is represented by three dots (…) followed by the parameter name and must be the last parameter in the function, enabling flexible and dynamic argument handling.

Default behavior:

All value support :

Specific value work using array index :

Since the rest parameter generates an array, the map will work :

Combining Arguments Dynamically :

When to Use the Rest and Spread Operator

Use the rest operator when handling an unknown number of function arguments or collecting remaining elements in array/object destructuring. The spread operator is ideal for expanding arrays/objects into individual elements or passing array items as function arguments.

Table

Conclusion: Rest vs Spread Operator

The rest operator gathers multiple elements into an array or object, ideal for handling variable arguments in functions or array/object destructuring. The spread operator expands elements from arrays, objects, or strings, simplifying tasks like copying, concatenation, or passing array elements as separate arguments in function calls.