JavaScript Variables

Variables are fundamental building blocks in JavaScript. They are containers for storing data values. Think of them as labeled boxes where you can put different types of information.

Declaring Variables

You can declare variables in JavaScript using three keywords:

var: The older way of declaring variables. It has function scope and can be redeclared and updated.
let: Introduced in ES6 (ECMAScript 2015), it has block scope and can be updated but not redeclared within the same scope.
const: Also introduced in ES6, it has block scope and cannot be reassigned. You must initialize a constant when you declare it.

Declaration Examples

Using let:

let message;
message = "Hello, World!";
console.log(message); // Output: Hello, World!

Using const:

const pi = 3.14159;
console.log(pi); // Output: 3.14159
// pi = 3.14; // This would cause an error

Using var (generally avoid in modern JS):

var count = 10;
console.log(count); // Output: 10

Variable Naming Rules

Variable names must start with a letter, an underscore (_), or a dollar sign ($).
Variable names cannot start with a number.
Variable names can only contain alphanumeric characters (letters A-Z, a-z, numbers 0-9) and underscores (_) or dollar signs ($).
Variable names are case-sensitive (myVariable is different from myvariable).
Reserved words (like if, for, while, function, let, const, etc.) cannot be used as variable names.

Valid and Invalid Names

Valid Names:

userName
_userId
$price
myVariable123

Invalid Names:

1stPlace (starts with a number)
my-variable (contains a hyphen)
class (reserved word)

Data Types

JavaScript has several primitive data types:

String: Represents sequences of characters, enclosed in quotes (" or ').
Number: Represents numeric values, including integers and floating-point numbers.
Boolean: Represents logical values, either true or false.
Undefined: A variable that has been declared but not assigned a value.
Null: Represents the intentional absence of any object value.
Symbol (ES6): A unique and immutable primitive value.
BigInt (ES2020): For integers larger than the maximum safe integer.

JavaScript also has a non-primitive data type:

Object: A collection of properties, where each property has a key and a value.

Data Type Examples

let greeting = "Hello there!";
let age = 30;
let isStudent = false;
let x; // x is undefined
let person = { firstName: "John", lastName: "Doe" };

The `typeof` Operator

The typeof operator can be used to find the type of a variable:

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

let score = 95;
console.log(typeof score); // Output: number

let isActive = true;
console.log(typeof isActive); // Output: boolean

let data;
console.log(typeof data); // Output: undefined

console.log(typeof null); // Output: object (This is a known quirk in JavaScript)

Best Practices

Use const by default for variables whose values will not change.
Use let when you know the variable's value will need to be reassigned.
Avoid using var in modern JavaScript development due to its hoisting and scoping behaviors.
Choose descriptive and meaningful variable names.