Variables and Data Types in JavaScript

#### 1. Introduction to Variables

In JavaScript, variables are containers for storing data values. They are like labeled boxes in which you can store information and reference later in your code.

#### 2. Declaring Variables

To declare a variable in JavaScript, you use the `var`, `let`, or `const` keyword followed by the variable name.

- `var` was traditionally used to declare variables, but it has some quirks. It has function-level scope and can be redeclared within the same scope.

- `let` is a modern way to declare variables with block-level scope. It allows you to reassign values but not redeclare the variable within the same scope.

- `const` is used for constants. Once assigned, the value of a constant cannot be changed.

```javascript

var a; // Declaring a variable named 'a'

let b = 5; // Declaring and initializing a variable named 'b' with the value 5

const PI = 3.14; // Declaring and initializing a constant named 'PI'

```

#### 3. Data Types

JavaScript has several built-in data types:

- **Primitive Data Types**:

- **Number**: Represents numeric values.

- **String**: Represents textual data.

- **Boolean**: Represents `true` or `false`.

- **Undefined**: Represents a variable that has been declared but not assigned a value.

- **Null**: Represents the intentional absence of any value.

- **Symbol**: Introduced in ES6, represents unique identifiers.

- **Complex Data Types**:

- **Object**: Represents a collection of key-value pairs.

- **Array**: Represents a collection of elements, usually of the same type, referenced by an index.

#### 4. Type Inference

JavaScript is a dynamically-typed language, meaning you don't have to explicitly specify the data type of a variable. The type of a variable is inferred at runtime based on the value assigned to it.

```javascript

let num = 10; // num is inferred as a number

let message = "Hello, world!"; // message is inferred as a string

let isStudent = true; // isStudent is inferred as a boolean

```

#### 5. Type Conversion

JavaScript also performs automatic type conversion, known as type coercion, when you try to perform operations between different data types.

```javascript

let x = 10;

let y = "5";

console.log(x + y); // Output: "105" (y is implicitly converted to a string)

```

#### 6. Checking Data Types

You can use the `typeof` operator to check the data type of a variable.

```javascript

let age = 25;

console.log(typeof age); // Output: "number"

let name = "John";

console.log(typeof name); // Output: "string"

let isMarried = false;

console.log(typeof isMarried); // Output: "boolean"

```

### 1. Global Scope

Variables declared outside of any function, or declared with `var` keyword outside of any block (ES5 and earlier), have global scope. These variables are accessible from anywhere in the code, including inside functions and blocks.

Example:

```javascript

var globalVar = "I am a global variable";

function myFunction() {

console.log(globalVar); // Output: "I am a global variable"

}

console.log(globalVar); // Output: "I am a global variable"

```

### 2. Local Scope

Variables declared inside a function, or declared with `let` or `const` inside a block (ES6+), have local scope. They are accessible only within the function or block in which they are declared.

#### Function Scope (ES5 and earlier):

```javascript

function myFunction() {

var localVar = "I am a local variable";

console.log(localVar); // Output: "I am a local variable"

}

myFunction();

console.log(localVar); // Throws ReferenceError: localVar is not defined

```

#### Block Scope (ES6+):

```javascript

function myFunction() {

if (true) {

let blockVar = "I am a block-scoped variable";

console.log(blockVar); // Output: "I am a block-scoped variable"

}

console.log(blockVar); // Throws ReferenceError: blockVar is not defined

}

myFunction();

```

### Nested Scope

Inner scopes have access to variables declared in outer scopes, but the reverse is not true. This is known as lexical scoping or closure.

Example:

```javascript

function outerFunction() {

var outerVar = "I am outer variable";

function innerFunction() {

console.log(outerVar); // Output: "I am outer variable"

}

innerFunction();

}

outerFunction();

```

### Scope Chain

When a variable is accessed within a function or block, JavaScript first looks for it in the local scope. If it's not found there, it looks in the outer (enclosing) scope, and continues up the chain until it reaches the global scope. If the variable is not found in any of these scopes, a ReferenceError is thrown.

### 1. Temperature Converter

- Celsius to Fahrenheit: `(Celsius * 9/5) + 32`

- Fahrenheit to Celsius: `(Fahrenheit - 32) * 5/9`

### 2. GPA Calculator

- GPA calculation: `(grade1 * credit1 + grade2 * credit2 + ... + gradeN * creditN) / (credit1 + credit2 + ... + creditN)`

### 3. Shopping Cart Total

- Total price calculation: `totalPrice = (price1 * quantity1) + (price2 * quantity2) + ... + (priceN * quantityN)`

### 4. Simple Interest Calculator

- Simple interest calculation: `Simple Interest = (Principal * Rate * Time) / 100`

### 5. Compound Interest Calculator

- Compound interest calculation: `Compound Interest = Principal * ((1 + Rate / 100) ^ Time) - Principal`