JavaScript – Syntax, Variables, Data Types & Examples

Example: Hello World in JavaScript

console.log("Welcome to JavaScript Learning!");
                    

JavaScript Values

In JavaScript, values represent the actual data that a program processes and manipulates. Every JavaScript expression evaluates to a value, whether it is a number, text, or a more complex data structure. A solid understanding of JavaScript values is essential for writing readable, maintainable, and reliable code.

JavaScript values are generally divided into two main categories:

• Fixed Values (Literals) – Values written directly into the source code.
• Variable Values (Variables) – Values stored in variables that can change while the program is running.

JavaScript Literals

Literals are fixed values that are written directly into JavaScript code. They represent constant data and do not change unless the code itself is modified. JavaScript supports several types of literals, such as numeric, string, boolean, and object literals.

let userAge = 25;
let productPrice = 99.99;
let temperatureCelsius = -5;

console.log(userAge);
console.log(productPrice);
console.log(temperatureCelsius);
    

Example: String Literals in JavaScript

let companyName = "TechWorld Solutions";
let courseTitle = 'JavaScript for Beginners';
let websiteStatus = "Online and Available";

console.log(companyName);
console.log(courseTitle);
console.log(websiteStatus);

JavaScript Variables

In JavaScript, a variable is a named container used to store data values. Variables allow programs to save information, reuse it, and update it dynamically as the code executes. They can store numbers, strings, objects, arrays, and even functions.

JavaScript provides three keywords for declaring variables: var, let, and const. Each keyword defines how the variable behaves in terms of scope and reassignment:

• var: The original way to declare variables. It is function-scoped and generally avoided in modern JavaScript.
• let: Block-scoped and recommended for variables whose values may change.
• const: Block-scoped and cannot be reassigned. Ideal for values that should remain constant.

Based on where they are declared, JavaScript variables are commonly categorized as:

• Local Variables – Declared inside a function or block and accessible only within that specific scope.
• Global Variables – Declared outside all functions or blocks and accessible throughout the entire program.

let programmingLanguage = "JavaScript"; // Global variable

function displayProfile() {
    let yearsOfExperience = 5; // Local variable
    console.log(programmingLanguage); // Accessible inside the function
    console.log(yearsOfExperience);    // Accessible inside the function
}

displayProfile();

// console.log(yearsOfExperience); 
// ❌ Error: Local variable is not accessible outside the function

JavaScript Operators

JavaScript operators are symbols that instruct the language to perform specific operations on values and variables. They are used to carry out calculations, compare data, and assign values, forming the core logic behind every JavaScript program.

JavaScript includes several categories of operators. Some of the most commonly used ones are:

• Arithmetic Operators – Used to perform mathematical operations such as addition (+), subtraction (-), multiplication (*), and division (/).
• Assignment Operators – Used to assign and update values stored in variables, most commonly using the = symbol.

let distanceInKm = 240;
let travelTimeInHours = 4;

// Calculate average speed using arithmetic operators
let averageSpeed = distanceInKm / travelTimeInHours;

console.log("Average Speed:", averageSpeed, "km/h");

JavaScript Expressions

A JavaScript expression is any valid piece of code that evaluates to a single value. Expressions can combine variables, operators, and literal values to produce a result. When JavaScript evaluates an expression, it returns a value that can be stored in a variable, displayed to the user, or used as part of another expression.

Expressions are widely used for performing calculations, processing data, and controlling program logic in real-world JavaScript applications.

let originalPrice = 80;
let discount = 20;

// Expression to calculate the discounted price
let finalPrice = originalPrice - discount;

// Expression to calculate half of the final price
let halfPrice = finalPrice / 2;

console.log("Final Price:", finalPrice);
console.log("Half Price:", halfPrice);

JavaScript Keywords

JavaScript keywords are reserved words that have a specific, predefined meaning within the language. They are used to define program structure, declare variables, create functions, control execution flow, and implement logic. Because keywords are an essential part of JavaScript syntax, they cannot be used as identifiers such as variable or function names.

Some commonly used JavaScript keywords include function, let, var, const, return, if, and else. These keywords help developers write structured, readable, and maintainable JavaScript programs.

function calculateTotalPrice(price, quantity) {
    let total = price * quantity;
    return total;
}

let itemPrice = 15;
let itemQuantity = 4;

let finalAmount = calculateTotalPrice(itemPrice, itemQuantity);
console.log("Total Amount:", finalAmount);

JavaScript Comments

JavaScript comments are explanatory notes written within the source code that are ignored by the JavaScript engine during execution. Although comments do not affect how a program runs, they are essential for improving code readability, long-term maintainability, and effective collaboration between developers.

Developers commonly use comments to explain complex logic, document important decisions, leave reminders, or temporarily disable sections of code while debugging or testing.

JavaScript supports two primary types of comments:

• Single-line comments
• Multi-line comments

// This is a single-line comment
let count = 5; // Initialize the counter with a starting value

Example: Common JavaScript Data Types

// String (Primitive)
let platformName = "TechWorld Academy";

// Number (Primitive)
let registeredUsers = 1250;

// Boolean (Primitive)
let isPlatformOnline = true;

// Array (Non-Primitive)
let supportedRegions = ["USA", "UK", "Canada", "Europe"];

// Object (Non-Primitive)
let instructorProfile = {
    name: "Alex Brown",
    experienceYears: 6,
    specialization: "JavaScript",
    active: true
};

console.log(platformName);
console.log(registeredUsers);
console.log(isPlatformOnline);
console.log(supportedRegions);
console.log(JSON.stringify(instructorProfile));

Example: JavaScript Function with Parameters and Return Value

function calculateFinalPrice(price, tax) {
    let total = price + tax;
    return total;
}

let productPrice = 45;
let taxAmount = 5;

let finalPrice = calculateFinalPrice(productPrice, taxAmount);
console.log("Final Price:", finalPrice);

Example: Valid JavaScript Identifiers

// Valid JavaScript identifiers
let userName = "Alice";
let _accountStatus = "Active";
let $monthlySubscription = 29.99;
let totalLogins2024 = 120;

console.log(userName);
console.log(_accountStatus);
console.log($monthlySubscription);
console.log(totalLogins2024);