(1). JavaScript: JavaScript is a lightweight, object-based scripting programming language primarily used for client-side validation.

(2). Features: JavaScript is known for its lightweight nature, as it's an interpreter and open-source, making it cross-platform compatible.

(3). Data Types:

  • Primitive Data Types: These include String, Number, BigInt, Boolean, Undefined, and Symbol.
  • Non-Primitive: Object.

(4). Data Types:

  • Primitive Data Types: These include String, Number, BigInt, Boolean, Undefined, and Symbol.

(5). Var: var is function-scoped and can be declared multiple times. It's also updatable.

(6). Let: let is block-scoped, can be updated, but cannot be re-declared.

(7). Const: const is block-scoped and cannot be reassigned.

(8). Types of Functions: JavaScript supports various types of functions, including Function Declaration, Function Expression, Arrow Function, and Anonymous Function.

(9). Array Declaration: Arrays can be created using an array literal, by creating an instance of an array, or using the Array Constructor.

(10). Hoisting: Hoisting moves all variable and function declarations to the top of their containing scope. Variables can be used before they are declared.

javascript
x = 5;
elem = document.getElementById("demo");
elem.innerHTML = x;
var x;

(11). Closures: Closures allow inner functions to access the scope of outer functions, even after the outer function has finished execution.

javascript
function init() {
  var name = 'prakash';
  function displayName() {
    console.log(name);
  }
  displayName();
}
init();

(12). Callbacks: Callbacks are functions that are executed after another function has finished execution.

javascript
function greeting(name) {
  alert(`Hello, ${name}`);
}

function processUserInput(callback) {
  const name = prompt("Please enter your name.");
  callback(name);
}

processUserInput(greeting);

(13). Hoisting: Hoisting moves variable and function declarations to the top of their containing scope.

javascript
x = 1;
y = x;
alert('x = ' + x);
alert('y = ' + y);
var x;
var y;

(14). Prototype: Objects in JavaScript inherit properties and methods from prototypes. Prototype-based inheritance allows you to add new variables and methods to existing objects.

(15). Undefined: Undefined means a variable is declared but not assigned a value.

(16). Null: Null is an assignment value that can be assigned to a variable.

(17). Equality (==): Double equals (==) is used for loose comparison between two variables regardless of their data types.

(18). Strict Equality (===): Triple equals (===) is used for strict comparison between two variables, including data type checking.

(19). Anonymous Function: An anonymous function is a function without a name.

javascript
var greet = function () {
  console.log("Welcome to GeeksforGeeks!");
};
greet();

(20). Synchronous: Synchronous code executes sequentially, one statement after another.

(21). Asynchronous: Asynchronous code allows non-blocking execution, enabling other code to run without waiting.

(22). Arrow Function: Arrow functions provide a shorter syntax for writing functions.

javascript
let sum = (a, b) => a + b;
console.log(sum(1, 2)); // 3

(23). StringBuffer: JavaScript doesn't have a built-in StringBuffer. You can manipulate strings using standard string methods.

(24). StringBuilder: JavaScript doesn't have a built-in StringBuilder. You can concatenate strings using the + operator.

(25). Pass By Value: Pass by value means a copy of the variable's value is passed to a function, and changes within the function don't affect the original variable.

(26). Pass By Reference: Pass by reference means a reference to the original variable is passed to a function, and changes within the function affect the original variable.

(27). For...In Loop: The for...in loop iterates through the properties of an object.

(28). For...Of Loop: The for...of loop iterates through the values of an iterable object.

(29). setTimeout: setTimeout allows you to execute a function once after a specified interval.

(30). setInterval: setInterval allows you to execute a function repeatedly at a specified interval.

(31). Map: The map method creates a new array by applying a given function to each element of the original array.

(32). Filter: The filter method creates a new array with all elements that pass a test implemented by the provided function.

(33). Reduce: The reduce method reduces an array to a single value by applying a function to each element and accumulating the result.

(34). InnerText: innerText is used to set or get the text content of an element, ignoring HTML tags.

(35). InnerHTML: innerHTML is used to set or get the HTML content of an element, including HTML tags.

(36). Async/Await: async and await are used to work with asynchronous code, making it more readable and structured.

(37). NaN (Not-a-Number): NaN represents a value that is not a valid number.

(38). DOM (Document Object Model): DOM is a programming interface for manipulating HTML and XML documents.

(39). Null: Null is an assignment value that can be assigned to a variable.

(40). Undefined: Undefined means a variable is declared but not assigned a value.

(41). Events: Events are actions or occurrences that happen in a system, such as user clicks or page loads.

(42). Event Propagation: Event propagation refers to how events travel through the DOM tree.

(43). Event Loop: The event loop allows non-blocking execution of code in a single thread.

(44). Generators: Generators are functions that yield values one at a time, allowing pausing and resuming execution.

(45). Destructuring: Destructuring allows unpacking values from arrays and properties from objects into distinct variables.

(46). Call(): The call() method is used to call a function with a given this value and arguments.

(47). Apply(): The apply() method is used to call a function with a given this value and an array of arguments.

(48). Bind(): The bind() method creates a new function with a specified this value and initial arguments.

(49). Generators: Generators are functions that yield values one at a time, allowing pausing and resuming execution.

(50). Destructuring: Destructuring is an expression that unpacks values from arrays or properties from objects into distinct variables.

(51). Scope Chain: The scope chain determines which variables or functions are accessible in a given part of code.

(52). IIFE (Immediately Invoked Function Expression): An IIFE is a function defined and executed immediately after creation.