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`
Contact us for software training, education or development
.png)
0 Comments