JavaScript Fundamental

• Lexical Structure: Understanding the syntax and structure of JavaScript code is fundamental for writing clean and concise code.
  • Case sensitivity: JavaScript is case sensitive, which means that variables foo and Foo are considered to be different.
  • Whitespace: JavaScript ignores most whitespace (e.g., spaces, tabs, and newlines), so you can use it to format your code in a way that makes it easier to read.
  • Line terminators: JavaScript uses the newline character (\n) to indicate the end of a line.
  • Semicolons: JavaScript uses semicolons (;) to separate statements. You can usually omit the semicolon if the statement is on a line by itself, but it is generally a good idea to use them consistently to avoid potential issues.
  • Comments: JavaScript supports two types of comments: single-line comments (//) and multi-line comments (/* */).
  • Identifiers: Identifiers are used to name variables, functions, and other elements in the code. They can contain letters, digits, underscores (_), and dollar signs ($), and must begin with a letter, an underscore, or a dollar sign.
  • Keywords: JavaScript has a set of reserved words that cannot be used as identifiers. These include words like var, function, and if.

// JS code is written in text files
// comments are used to annotate the code
// all statements are separated by semicolons

let x = 5;
console.log(x);

• Expressions: Learning how expressions are evaluated and used in JavaScript is essential for effective programming.

// expressions are pieces of code that produce values
// they can be as simple as a single value or complex combinations of values and operators

let a = 5;
let b = 10;
let result = a + b * 2;
console.log(result); // Output: 25

• Data Types: Familiarizing yourself with JavaScript data types, including strings, numbers, booleans, null, undefined, symbol, and objects, lays the groundwork for efficient programming.

// JS has several built-in data types such as strings, numbers, booleans, and objects

let str = "Hello";
let num = 10;
let bool = true;
let obj = { key: "value" };

• Classes: Exploring object-oriented programming concepts using classes enhances code organization and reusability.

// classes are blueprints for creating objects with similar properties and methods

class rectangle {
  constructor(width, height) {
    this.width = width;
    this.height = height;
  }
  getArea() {
    return this.width * this.height;
  }
}
let rect = new rectangle(5, 10);
console.log(rect.getArea()); // Output: 50

• Variables: Knowing how to declare and use variables using var, let, and const is fundamental for managing data in JavaScript.

// variables are used to store data values
// they can be declared using var, let, or const keywords


let x = 5; // Declaring a variable using let
const PI = 3.14; // Declaring a constant

• Functions: Functions are the building blocks of JavaScript. Mastering function declarations, expressions, and arrow functions is essential for writing modular and maintainable code.

// functions are reusable blocks of code that perform a specific task
// they can be declared using function declarations, expressions, or arrow functions

function greeting(name) {
  return "Hello, " + name + "!";
}
console.log(greeting("from gfg")); // Output: Hello, from gfg!

• this Operator: Understanding how the this keyword behaves in different contexts is crucial for writing object-oriented JavaScript code.

/*  'this' keyword refers to the object that is executing the current function 
its value depends on how a function is called */

const obj = {
  name: "happy learning from gfg",
  greet: function() {
    return "Hello, " + this.name + "!";
  }
};
console.log(obj.greet()); // Output: Hello, happy learning from gfg!

• Arrow Functions: Learning about arrow functions and their concise syntax for defining functions improves code readability and maintainability.

/* arrow functions provide a concise syntax for defining functions
they don't have their own 'this' context */

const add = (a, b) => a + b;
console.log(add(5, 10)); // Output: 15

• Loops: Grasping loop structures like for and while for iterating over data enhances code efficiency and logic.

/* loops are used to execute a block of code repeatedly
 common loop structures include for and while loops */

for (let i = 0; i < 5; i++) {
  console.log(i); // Output: 0, 1, 2, 3, 4
}

• Scopes: Understanding variable scopes and how they affect the visibility and accessibility of variables is essential for writing bug-free code.

/* scopes determine the visibility and accessibility of variables
variables declared with var have function scope, while let and const have block scope*/

function example() {
  var x = 5;
  if (true) {
    let y = 10;
    console.log(x); // Output: 5
    console.log(y); // Output: 10
  }
  console.log(x); // Output: 5
  // console.log(y); // Error: y is not defined
}

• Arrays: Exploring array methods and operations for working with collections of data enhances code efficiency and productivity.

/* arrays are used to store collections of data
 they come with various methods and operations for manipulation */

let numbers = [1, 2, 3, 4, 5];
numbers.push(6);
console.log(numbers); // Output: [1, 2, 3, 4, 5, 6]

• Template Literals: Utilizing template literals for string interpolation and multiline strings improves code readability and maintainability.

/*  template literals allow for string interpolation and multiline strings
 They are enclosed in backticks (`) instead of single or double quotes  */

let name = "Sharuk khan";
console.log(`Hello, ${name}!`); // Output: Hello, Sharuk khan!

• Strict Mode: Familiarizing yourself with strict mode enforces better coding practices and helps catch common programming errors.

/* strict mode enforces stricter parsing and error handling in JavaScript
 it helps catch common programming errors and promotes better coding practices */

"use strict";
x = 5; // Error: x is not defined

• ECMAScript 2015 (ES6) and beyond: Embracing modern JavaScript features introduced in ES6 and later versions enhances code quality and productivity.

/* ES6 has introduced several new features such as let and const for variable declarations, arrow functions, classes, etc.
these features enhance code quality and productivity */

const square = (x) => x * x;
console.log(square(5)); // Output: 25

NodeJS has revolutionized web development by enabling developers to create powerful server-side applications using JavaScript. If you’re new to NodeJS, you might wonder how much JavaScript knowledge you need to get started. In this guide, we’ll explore the essential JavaScript skills required to dive into NodeJS and build robust applications.