Variables, Data Types, and Operators in JS

Variables, Data Types, and Operators

JavaScript is a dynamically typed language, which means you do not need to specify the data type of a variable when you declare it. In this chapter, we will explore how variables work, the different data types available, and the various operators you can use in JavaScript.

Understanding Variables in JavaScript

Variables are containers used to store data values. In JavaScript, you can declare variables using three keywords: var, let, and const.

Declaring Variables

// Using var (Old method, function-scoped)
var name = "John";

// Using let (Modern, block-scoped)
let age = 25;

// Using const (Constant, block-scoped)
const pi = 3.14159;

Key Differences

• var is function-scoped and can be re-declared.
• let is block-scoped and cannot be re-declared in the same scope.
• const is block-scoped and must be initialized when declared. It cannot be re-assigned.

Data Types in JavaScript

JavaScript has seven primary data types, which can be categorized as Primitive Types and Non-Primitive Types.

Primitive Types:

• String: Textual data.

let text = "Hello, World!";

• Number: Numeric values (integer, float).

let number = 42;
let price = 99.99;

• Boolean: Represents true or false.

let isActive = true;

• Undefined: A variable declared but not assigned a value.

let value;
console.log(value); // Output: undefined

• Null: Represents a non-existent or empty value.

let empty = null;

• Symbol: Unique identifier (used in advanced concepts).

let uniqueId = Symbol("id");

• BigInt: Large integers beyond the safe integer limit.

let largeNumber = 12345678901234567890n;

Non-Primitive Types:

• Object: A complex data type that can store collections of values.

let person = {
  name: "Alice",
  age: 30,
  isActive: true
};

• Array: A list of values stored as a single variable.

let fruits = ["Apple", "Banana", "Cherry"];

• Function: A reusable block of code.

function greet() {
  console.log("Hello, World!");
}

Dynamic Typing in JavaScript

JavaScript is a dynamically typed language, meaning the type of a variable can change during runtime.

let data = 42;      // data is a Number
data = "Hello";     // data is now a String
data = true;        // data is now a Boolean

Operators in JavaScript

Operators are symbols that perform operations on values or variables. JavaScript has several types of operators:

1. Arithmetic Operators

let a = 10;
let b = 3;

console.log(a + b);  // Addition (Output: 13)
console.log(a - b);  // Subtraction (Output: 7)
console.log(a * b);  // Multiplication (Output: 30)
console.log(a / b);  // Division (Output: 3.333)
console.log(a % b);  // Modulus (Remainder) (Output: 1)
console.log(a ** b); // Exponentiation (Output: 1000)

2. Assignment Operators

let x = 5;
x += 2; // Same as x = x + 2
x -= 1; // Same as x = x - 1
x *= 3; // Same as x = x * 3
x /= 2; // Same as x = x / 2

3. Comparison Operators

These are used to compare two values.

console.log(10 > 5);   // Greater than (true)
console.log(10 < 5);   // Less than (false)
console.log(10 == 5);  // Equal to (false)
console.log(10 === "10"); // Strictly equal (false)
console.log(10 !== 5); // Not equal (true)

4. Logical Operators

These are used to perform logical operations.

let isAdult = true;
let hasPermission = false;

console.log(isAdult && hasPermission); // AND (false)
console.log(isAdult || hasPermission); // OR (true)
console.log(!isAdult);                 // NOT (false)

5. Ternary Operator (Conditional Operator)

A compact way of writing conditional statements.

let age = 18;
let canVote = (age >= 18) ? "Yes" : "No";
console.log(canVote); // Output: Yes

6. Type Operators

• typeof: Returns the type of a variable.

console.log(typeof 42);           // "number"
console.log(typeof "Hello");      // "string"
console.log(typeof true);         // "boolean"

• instanceof: Checks if an object is an instance of a particular type.

let date = new Date();
console.log(date instanceof Date); // true

Variable Scope in JavaScript

JavaScript has three main types of scope:

• Global Scope: Variables declared outside any function.
• Local Scope: Variables declared inside a function.
• Block Scope: Variables declared with let or const inside a block ({}).

Example:

let globalVar = "I am global";

function testScope() {
  let localVar = "I am local";
  if (true) {
    let blockVar = "I am block-scoped";
    console.log(blockVar); // Accessible here
  }
  // console.log(blockVar); // Error: blockVar is not defined
}

testScope();

Best Practices for Using Variables

• Use const for values that should not change.
• Use let for variables that may change.
• Avoid using var due to its function-scoped behavior.
• Use descriptive variable names (e.g., userName instead of x).
• Follow camelCase naming convention for variables and functions.

Quick Recap

• Variables store data values. Use let and const instead of var.
• JavaScript has seven primitive data types and complex types (objects, arrays).
• Operators allow you to perform arithmetic, logical, and comparison operations.
• Use typeof to check the data type of a variable.
• Scope defines where a variable can be accessed (global, local, block).