JavaScript Data Types

Program demonstrating different data types in JavaScript

BeginnerTopic: Basic Programs

JavaScript JavaScript Data Types Program

This program helps you to learn the fundamental structure and syntax of JavaScript programming.

// Primitive Data Types
console.log("=== Primitive Types ===");

// Number
let age = 25;
let price = 99.99;
console.log("Number:", age, typeof age);
console.log("Float:", price, typeof price);

// String
let name = "John";
let message = 'Hello World';
let template = `Name: ${name}`;
console.log("String:", name, typeof name);
console.log("Template Literal:", template);

// Boolean
let isActive = true;
let isComplete = false;
console.log("Boolean:", isActive, typeof isActive);

// Undefined
let undefinedVar;
console.log("Undefined:", undefinedVar, typeof undefinedVar);

// Null
let nullVar = null;
console.log("Null:", nullVar, typeof nullVar);

// Symbol (ES6)
let sym = Symbol("id");
console.log("Symbol:", sym, typeof sym);

// BigInt (ES2020)
let bigNumber = 9007199254740991n;
console.log("BigInt:", bigNumber, typeof bigNumber);

// Reference Types
console.log("\n=== Reference Types ===");

// Object
let person = {
    name: "John",
    age: 25
};
console.log("Object:", person, typeof person);

// Array
let numbers = [1, 2, 3, 4, 5];
console.log("Array:", numbers, typeof numbers);

// Function
function greet() {
    return "Hello";
}
console.log("Function:", greet, typeof greet);

Output

=== Primitive Types ===
Number: 25 number
Float: 99.99 number
String: John string
Template Literal: Name: John
Boolean: true boolean
Undefined: undefined undefined
Null: null object
Symbol: Symbol(id) symbol
BigInt: 9007199254740991n bigint
=== Reference Types ===
Object: { name: 'John', age: 25 } object
Array: [ 1, 2, 3, 4, 5 ] object
Function: [Function: greet] function

Understanding JavaScript Data Types

This program demonstrates all data types available in JavaScript.

Primitive Data Types

Primitives are immutable values stored directly in memory:

Number

: Integers and floating-point numbers

•typeof 42 → "number"

•Includes Infinity, -Infinity, NaN

String

: Text data

•Single quotes: 'text'

•Double quotes: "text"

•Template literals: `text`

Boolean

: true or false

•Used in conditionals and logic

Undefined

: Variable declared but not assigned

•let x; console.log(x); → undefined

Null

: Intentional absence of value

•typeof null → "object" (historical bug)

Symbol

: Unique identifier (ES6)

•Used for object property keys

BigInt

: Large integers (ES2020)

•Append n to number: 9007199254740991n

Reference Data Types

Stored as references, not values:

Object

: Key-value pairs

   { name: "John", age: 25 }

Array

: Ordered list

   [1, 2, 3, 4, 5]

Function

: Callable code block

   function greet() { return "Hello"; }

Type Checking

Use typeof operator to check types:

typeof 42;        // "number"
typeof "text";    // "string"
typeof true;      // "boolean"
typeof undefined; // "undefined"
typeof null;      // "object" (bug!)
typeof {};        // "object"
typeof [];        // "object"
typeof function(){}; // "function"

Important Notes:

•JavaScript is dynamically typed

•Variables can change types

•Use === for strict equality checks

•typeof null returns "object" (historical bug)

Let us now understand every line and the components of the above program.

Note: To write and run JavaScript programs, you need to set up the local environment on your computer. Refer to the complete article Setting up JavaScript Development Environment. If you do not want to set up the local environment on your computer, you can also use online IDE to write and run your JavaScript programs.

Practical Learning Notes for JavaScript Data Types

This JavaScript program is part of the "Basic Programs" topic and is designed to help you build real problem-solving confidence, not just memorize syntax. Start by understanding the goal of the program in plain language, then trace the logic line by line with a custom input of your own. Once you can predict the output before running the code, your understanding becomes much stronger.

A reliable practice pattern is to run the original version first, then modify only one condition or variable at a time. Observe how that single change affects control flow and output. This deliberate style helps you understand loops, conditions, and data movement much faster than copying full solutions repeatedly.

For interview preparation, explain this solution in three layers: the high-level approach, the step-by-step execution, and the time-space tradeoff. If you can teach these three layers clearly, you are ready to solve close variations of this problem under time pressure.

Arithmetic Operations

Swap Two Numbers