Get Started in JavaScript Episode 2: Building a JavaScript Fundamentals

Dive deep into core JavaScript concepts like variables, data types, control structures, functions, arrays, objects, and error handling. Perfect for beginners looking to build a strong coding foundation. Includes exercises and resources to level up skills.

Welcome to the second episode of our comprehensive JavaScript learning series!

In the first episode, we talk about foundations of JavaScript, HTML, CSS. In this episode, we will dive deep into the fundamental concepts of JavaScript, providing beginners with a solid foundation to build upon. By the end of this episode, you'll have a clear understanding of variables, data types, operators, control structures, functions, arrays, objects, and error handling. So let's get started!

Table of Contents

  1. Introduction
  2. Variables, Data Types, and Operators
  3. Control Structures
  4. Functions and Scope
  5. Arrays and Objects
  6. Error Handling (try-catch)
  7. Resources for Further Learning

1. Introduction

JavaScript is a versatile and dynamic programming language used to build interactive and engaging web applications. In this episode, we're going to explore the essential concepts that lay the foundation for your JavaScript journey. Whether you're new to programming or looking to solidify your fundamentals, this episode will equip you with the knowledge you need to write effective JavaScript code.

2. Variables, Data Types, and Operators

Variables: Storing and Managing Data

Variables are like labeled containers that hold different types of information. They give your programs the ability to store and manipulate data. Think of a variable as a named box that can hold various types of values, such as numbers, strings, and objects.

// Variable Declaration
let age = 25; // Declares a variable named 'age' with the value 25
const name = "Alice"; // Declares a constant variable named 'name'

Data Types: Understanding Types of Values

JavaScript supports several data types, each serving a specific purpose. Understanding these types is crucial for working with data effectively.

  • Numbers: Used for numeric values, including integers and floating-point numbers.
  • Strings: Used for textual data and characters. Enclosed in single or double quotes.
  • Booleans: Represent true or false values, critical for making decisions in your code.
  • Null: Represents the intentional absence of value.
  • Undefined: Indicates a variable that has been declared but not assigned a value.
  • Objects: Complex data structures that store key-value pairs.
  • Arrays: Ordered lists of values, accessible by index.
// Data Types
let score = 95; // Number
let message = "Hello, world!"; // String
let isReady = true; // Boolean
let player = null; // Null
let address; // Undefined
let person = { name: "John", age: 30 }; // Object
let colors = ["red", "green", "blue"]; // Array

Operators: Performing Actions

Operators enable you to perform actions on variables and values. They are the building blocks for creating expressions and executing operations.

  • Arithmetic Operators: Perform basic math operations like addition, subtraction, multiplication, and division.
  • Comparison Operators: Compare values and return true or false.
  • Logical Operators: Combine conditions and control program flow.
  • Assignment Operators: Assign values to variables.
  • String Operators: Concatenate strings together.
  • Increment/Decrement Operators: Modify numeric values.
// Operators
let sum = 10 + 5; // Addition
let isGreater = 15 > 10; // Comparison
let isLoggedIn = true;
let isAdmin = false;
let canAccess = isLoggedIn && isAdmin; // Logical AND
let fullName = "John" + " " + "Doe"; // String concatenation
let counter = 0;
counter++; // Increment

Understanding variables, data types, and operators is like learning the grammar and vocabulary of a new language. These concepts empower you to express ideas and perform actions in your code. In the next section, we'll explore how to control the flow of your program using control structures.

Variables: var, let, and const

In JavaScript, variables are used to store and manage data. They play a crucial role in programming by allowing you to name and refer to values, making your code more readable and maintainable. JavaScript provides three different ways to declare variables: var, let, and const. Each has its own scope and behavior, which affects how variables are used and accessed within your code.

var: Legacy Scoped Variable

var was the original way to declare variables in JavaScript. It has global scope if declared outside of functions and function scope if declared within a function. However, var has some quirks that can lead to unintended behavior, especially when it comes to variable hoisting and scope.

var x = 10; // Global scope

function example() {
    var y = 5; // Function scope
    if (true) {
        var z = 20; // Function scope

console.log(x); // 10
console.log(y); // ReferenceError: y is not defined
console.log(z); // 20

let: Block-Scoped Variable

Introduced in ECMAScript 6 (ES6), let is block-scoped, meaning it's limited in scope to the block, statement, or expression where it's defined. This resolves some of the issues associated with var and makes your code more predictable and easier to reason about.

let a = 15; // Block scope

if (true) {
    let b = 10; // Block scope
    console.log(a); // 15
    console.log(b); // 10

console.log(a); // 15
console.log(b); // ReferenceError: b is not defined

const: Immutable, Block-Scoped Variable

Similar to let, const was also introduced in ES6. It is used to declare variables that should never change their value after initial assignment. This makes const variables suitable for constants or values that shouldn't be re-assigned accidentally.

const PI = 3.14159; // Block scope

if (true) {
    const MAX_SIZE = 100; // Block scope
    console.log(PI); // 3.14159
    console.log(MAX_SIZE); // 100

console.log(PI); // 3.14159
console.log(MAX_SIZE); // ReferenceError: MAX_SIZE is not defined

Choosing the Right Keyword

  • Use var only if you have specific reasons to do so, as it has been largely replaced by let and const.
  • Use let when you need to reassign the variable's value.
  • Use const when you want to create a variable that should never change its value.

By using the appropriate variable declaration keyword, you can control the scope and mutability of your variables, leading to more predictable and maintainable code. It's recommended to use let and const over var in modern JavaScript development.

Exercise: Simple Calculator

Create a simple calculator function that takes two numbers and an operator as inputs and returns the result of the operation. Support basic arithmetic operations like addition, subtraction, multiplication, and division.

function simpleCalculator(num1, operator, num2) {
    if (operator === "+") {
        return num1 + num2;
    } else if (operator === "-") {
        return num1 - num2;
    } else if (operator === "*") {
        return num1 * num2;
    } else if (operator === "/") {
        return num1 / num2;
    } else {
        return "Invalid operator";

// Test the calculator
console.log(simpleCalculator(10, "+", 5)); // 15
console.log(simpleCalculator(20, "*", 3)); // 60
console.log(simpleCalculator(15, "/", 3)); // 5
console.log(simpleCalculator(8, "%", 2)); // Invalid operator

3. Control Structures

Control structures allow you to direct the flow of your code based on conditions and loops. They provide the ability to make decisions and execute code blocks repeatedly, giving your programs flexibility and interactivity.

If Statements: Making Informed Choices

if statements are the foundation of decision-making in programming. They allow your code to take different paths depending on whether a specified condition is true or false. By using if statements, you can create responsive programs that adapt to different scenarios.

let temperature = 25;

if (temperature > 30) {
    console.log("It's a hot day!");
} else if (temperature > 20) {
    console.log("It's a nice day.");
} else {
    console.log("It's a bit chilly.");

Exercise: Weather Decision

Write a function that takes the current temperature as an argument and prints out a message advising what to wear based on the temperature. For example, if the temperature is above 25°C, the function could print "Wear light clothes."

function suggestClothing(temperature) {
    if (temperature > 30) {
        return "Wear light and breathable clothing.";
    } else if (temperature > 20) {
        return "Wear comfortable clothing.";
    } else {
        return "Wear warm clothing.";

console.log(suggestClothing(28)); // "Wear comfortable clothing."
console.log(suggestClothing(10)); // "Wear warm clothing."

4. Functions and Scope

Functions: Building Blocks of Reusability

Functions are like mini-programs within your program. They encapsulate a set of instructions into a single block that can be reused throughout your code. Functions enhance readability, promote modular design, and make your code easier to maintain.

function greet(name) {
    return "Hello, " + name + "!";

let message = greet("Alice");
console.log(message); // Outputs: "Hello, Alice!"

Scope: Controlling Variable Visibility

Scope refers to the context in which variables are defined and accessible. Understanding scope is crucial for preventing naming conflicts and managing variable lifetimes.

  • Global Scope: Variables declared outside of any function or block are globally scoped and accessible throughout your code.
  • Function Scope: Variables declared within a function are only accessible within that function.
  • Block Scope: Introduced by let and

const, variables declared within a block (e.g., inside an if statement) are limited in scope to that block.

let globalVar = "I am global.";

function example() {
    let localVar = "I am local.";
    console.log(globalVar); // Accessible

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

Exercise: Temperature Conversion

Write a function that converts temperatures from Celsius to Fahrenheit and vice versa. The function should take a temperature value and a unit ('C' or 'F') as arguments and return the converted temperature.

function convertTemperature(value, unit) {
    if (unit === "C") {
        return (value * 9/5) + 32;
    } else if (unit === "F") {
        return (value - 32) * 5/9;
    } else {
        return "Invalid unit";

console.log(convertTemperature(25, "C")); // 77
console.log(convertTemperature(68, "F")); // 20
console.log(convertTemperature(0, "K")); // Invalid unit

5. Arrays and Objects

Arrays: Organizing Lists of Data

Arrays are versatile data structures that allow you to store multiple values in a single variable. Each value is assigned an index, starting from 0. Arrays are particularly useful for storing collections of similar items, such as numbers or strings.

let fruits = ["apple", "banana", "orange"];
console.log(fruits[0]); // Outputs: "apple"

Objects: Structuring Complex Data

Objects enable you to organize more complex data by grouping related information together in key-value pairs. Each value is associated with a descriptive key, providing a convenient way to access and manipulate data.

let person = {
    name: "John",
    age: 30,
    isStudent: false

console.log(; // Outputs: "John"

Exercise: Task List

Create a task list using an array of objects. Each object should represent a task with properties like title, description, and isCompleted. Use a loop to print each task's title and status.

let tasks = [
    { title: "Complete JavaScript exercises", isCompleted: true },
    { title: "Read a chapter from a book", isCompleted: false },
    { title: "Go for a walk", isCompleted: false }

for (let i = 0; i < tasks.length; i++) {
    let status = tasks[i].isCompleted ? "completed" : "not completed";
    console.log(`Task: ${tasks[i].title} - Status: ${status}`);

6. Error Handling (try-catch)

Graceful Error Management

Error handling is crucial to ensure your programs behave gracefully, even when unexpected issues arise. The try and catch statements allow you to handle errors without crashing your entire application.

try {
    // Code that might throw an error
} catch (error) {
    // Code to handle the error

Exercise: Divide by Zero

Write a function that takes two numbers as arguments and divides them. Wrap the division operation in a try block and catch any potential errors (e.g., division by zero) in the catch block.

function divide(a, b) {
    try {
        if (b === 0) {
            throw new Error("Division by zero is not allowed.");
        return a / b;
    } catch (error) {
        return "Error: " + error.message;

console.log(divide(10, 2)); // 5
console.log(divide(8, 0)); // Error: Division by zero is not allowed.

Congratulations on mastering the foundational artistry of JavaScript! Your journey has only just begun, and the world of programming beckons with endless possibilities. To sharpen your skills and broaden your horizons, consider these resources:

As you ascend into the next levels of JavaScript mastery, remember: your code is your canvas, and your keyboard is your brush. Now go forth, create, and shape the digital world as only you can. The adventure continues!

What next?

Read Episode 3

Subscribe to JS Dev Journal

Don’t miss out on the latest issues. Sign up now to get access to the library of members-only issues.