Javascript on Ghafoor's Personal Blog

Javascript Apis

noreply@example.com (AG Sayyed) — Mon, 24 Mar 2025 13:01:47 +0000

This document explains how to work with JavaScript APIs to manipulate HTML elements and nodes. It covers methods for retrieving, creating, and modifying elements, as well as managing window objects and events to enhance web page interactivity.

JavaScript APIs

An API, or Application Programming Interface, is a mechanism that allows two systems to communicate with each other. It acts as a messenger that takes your request to another system, such as a server or database, and delivers the response back to you.

JavaScript Functions

noreply@example.com (AG Sayyed) — Mon, 24 Mar 2025 10:04:34 +0000

This document explains JavaScript functions, prototypes, and self-executing functions. It covers how functions are declared, how prototypes simplify the addition of properties and methods to objects, and how self-executing functions isolate variables and initialize data.

JavaScript Functions

Function Declaration and Usage

A function is a block of reusable code that can be called after being declared.
Functions consist of:
- The function keyword.
- A name for the function.
- Parentheses for optional parameters.
- Curly braces containing the logic.
- An optional return statement to return a value.

Example: Function Declaration

1function add(a, b) {
2 return a + b
3}
4console.log(add(5, 10)) // Output: 15

Functions in JavaScript are loosely typed, meaning the data type of arguments is determined at runtime.
Functions can return different types based on the input, such as adding numbers or concatenating strings.

JavaScript Prototypes

Overview of Prototypes

Prototypes allow properties and methods to be shared across all instances of an object.
Objects created with the new keyword inherit properties and methods from their prototype.

Example: Using Prototypes

 1function Car(make, model, year) {
 2 this.make = make
 3 this.model = model
 4 this.year = year
 5}
 6
 7Car.prototype.getName = function () {
 8 return `${this.make} ${this.model} (${this.year})`
 9}
10
11const car1 = new Car('Toyota', 'Corolla', 2020)
12console.log(car1.getName()) // Output: Toyota Corolla (2020)

Adding a method to a prototype ensures all instances of the object inherit the method.
Changes to the prototype are reflected in all instances.

Self-Executing Functions

What Are Self-Executing Functions

Self-executing functions, also known as auto-invocation or immediately invoked function expressions (IIFE), run immediately after being declared.
These functions isolate variables and logic from the global scope.

Example: Self-Executing Function

1;(function () {
2 const message = 'Hello, World!'
3 console.log(message)
4})() // Output: Hello, World!

Self-executing functions are often used for initialization tasks or to declare DOM elements.
Variables and functions inside an IIFE are not accessible outside of it.

Conclusion

JavaScript functions provide reusable blocks of code, while prototypes simplify the addition of shared properties and methods to objects. Self-executing functions isolate logic and variables, making them useful for initialization and encapsulation.

JavaScript Control Statements

noreply@example.com (AG Sayyed) — Mon, 24 Mar 2025 03:33:44 +0000

This document explains JavaScript control statements, including conditional statements like "if" and "switch", and loops like "for", "while", and "do-while". It demonstrates how these statements enable developers to control program flow and create dynamic web applications.

JavaScript Control Statements

Control statements in JavaScript allow developers to direct program flow based on conditions and execute code repeatedly using loops. These statements help create dynamic and interactive web applications by enabling efficient data handling and user interaction.

Javascript Variables

noreply@example.com (AG Sayyed) — Mon, 24 Mar 2025 03:28:07 +0000

This document explains JavaScript variables, their declaration, initialization, and scope, as well as control statements like conditional statements, switch statements, and loops. It highlights how these features enable dynamic program flow and efficient data handling in JavaScript.

JavaScript Variables

Declaration and Initialization

Variables are declared using the var keyword followed by the variable name, e.g., var age.
Variables can be initialized during declaration, e.g., var age = 54, or assigned a value later.
JavaScript is loosely typed, so variables take their data type from the assigned value and can change type during execution.
Uninitialized variables have a value of undefined.

Rules for Variable Names

Must start with a letter, underscore (_), or dollar sign ($).
Subsequent characters can include letters, digits (0-9), underscores, or dollar signs.
Variable names are case-sensitive.

Scope of Variables

Local Scope: Variables declared within a function are accessible only inside that function.
Global Scope: Variables declared outside a function or without the var keyword are accessible throughout the program.

Example: Variable Declaration and Control Statements

Variable Declaration

1var name = 'John'
2var age = 30
3console.log(name + ' is ' + age + ' years old.')

If Statement

1if (age > 18) {
2 console.log('Adult')
3} else {
4 console.log('Minor')
5}

For Loop

1for (var i = 0; i < 5; i++) {
2 console.log('Iteration ' + i)
3}

Conclusion

JavaScript variables allow dynamic data handling with flexible typing and scoping rules.