DEV Community: Chandru P

Javascript Essentials Switch Statements and Ternary Example.

Chandru P — Sat, 06 Jun 2026 07:20:57 +0000

JavaScript conditional statements allow your code to make decisions. Switch statements evaluate a single expression against multiple possible values to execute specific blocks of code, while the ternary operator acts as a concise, one-line shorthand for a standardif...else statement.

1. Switch Statements
A switch statement is ideal when you have one variable being compared to many strict equality (===) conditions. Using break prevents the code from falling through to the next case.

Switch Control Flow

**
Based on a condition, switchselects one or more** code blocks to be executed.**

switchexecutes the code blocks that matches an expression.

switch is often used as a more readable alternative to many if...else if...else statements, especially when dealing with multiple possible values.
This is how it works:

The switch expression is evaluated once.
The value of the expression is compared with the values of each case.
If there is a match, the associated block of code is executed.
If there is no match, no code is executed.

**

## Example
**

switch (new Date().getDay()) {
case 0:
day = "Sunday";
break;
case 1:
day = "Monday";
break;
case 2:
day = "Tuesday";
break;
case 3:
day = "Wednesday";
break;
case 4:
day = "Thursday";
break;
case 5:
day = "Friday";
break;
case 6:
day = "Saturday";
}

const role = "admin";
let accessLevel;

switch (role) {
  case "user":
    accessLevel = "Standard read access";
    break;
  case "editor":
    accessLevel = "Read and write access";
    break;
  case "admin":
    accessLevel = "Full system access";
    break;
  default:
    accessLevel = "No access granted";
}

console.log(accessLevel); 
// Output: Full system access

2. Ternary Operator

The ternary operator is written as condition ? expressionIfTrue :expressionIfFalse. It is highly efficient for quick variable assignments or simple inline checks.

const isMember = true;
const discount = isMember ? 0.20 : 0.00;

console.log(`Your discount is ${discount * 100}%`); 
// Output: Your discount is 20%

You can even nest ternary operators for multiple checks, though doing so can affect readability:

const score = 85;
const grade = score >= 90 ? "A" : score >= 80 ? "B" : "C";

The break Keyword

When JavaScript reaches a break keyword, it** breaks out of the switch block.**

This will **stop the execution **inside the switch block.

No more statements in the switch block will be executed.

It is not necessary to break the last case. The switch ends (breaks) there anyway.
`

**`The break keyword is crucial for preventing a "fall-through."

Without break, the code will continue to execute the next case blocks (and the default block if present) even if their values do not match the expression.**

Conditional Statements In Javascript.

Chandru P — Thu, 04 Jun 2026 07:21:37 +0000

JavaScript conditional statements are used to make decisions in a program based on given conditions. They control the flow of execution by running different code blocks depending on whether a condition is true or false.

Conditions are evaluated using comparison and logical operators.
They help in building dynamic and interactive applications by responding to different inputs.

How to use the if statement in JavaScript
The if statement is the basic form of a conditional logic in JavaScript. It checks whether a condition is true and runs a block of code if it is.

Types of Conditional Statements

1.`if` Statement;-

The if statement checks a condition written inside parentheses. If the condition evaluates to true, the code inside {} is executed; otherwise, it is skipped.

Executes code only when a specified condition is true.
Useful for making simple decisions in a program.

Syntax:

let x = 20;

if (x % 2 === 0) {
    console.log("Even");
}

if (x % 2 !== 0) {
    console.log("Odd");
};

output;-

  `Even`

2. `if-else`Statement

The if-else statement executes one block of code if a condition is true and another block if it is false. It ensures that exactly one of the two code blocks runs.

Used when there are two possible outcomes.
The else block runs when the if condition is not satisfied.

let age = 25;

if (age >= 18) {
    console.log("Adult")
} else {
    console.log("Not an Adult")
};

Output
Adult

3. `else if` Statement

The else if statement is used to test multiple conditions in sequence. It executes the first block whose condition evaluates to true.

Allows checking more than two conditions.
Evaluated from top to bottom until a true condition is found.

const x = 0;

if (x > 0) {
    console.log("Positive.");
} else if (x < 0) {
    console.log("Negative.");
} else {
    console.log("Zero.");
};

Output;
Zero.
Summary

" width="728" height="308">

There are different types of conditional statements in JavaScript, just as they are in other programming languages but I will focus on these two:

The most common conditional statement used often is the IF-ELSE statement. just as the name goes, if something is true, do something. otherwise, do something else.

study the image below for reference:

This is the syntax for the if-else statement:

if (condition) {
    // If the condition is true, this code block will run
} else {
    // If the condition is false, this code block will run
}

In some cases, you might want to check several, related conditions. In those scenarios, you can use an else-if to evaluate the extra conditions.

if (condition) {
    // If the condition is true, this code block will run, and code execution
    // will stop.
} else if (conditiontwo) {
    // If the first condition is false, this code block will run if conditiontwo
    // is true
} else if (condition_n) {
    // If the previous conditions are both falsy, this code block will run if
    // condition_n is true
} else {
    // If all conditions are false, this code block will run
}

     [`https://miro.medium.com/v2/resize:fit:640/format:webp/1*GDrqEYJgxTHzKbKHaMkUiA.png`](url)

Conditional statements in JavaScript rely on a set of three basic syntax keywords: if, else and else if.

" width="698" height="440">

This is the syntax for the if-else statement.

Java script Operators.

Chandru P — Wed, 03 Jun 2026 08:06:52 +0000

JavaScript operators are special symbols or keywords used to perform calculations, combine values, modify variables, and execute logical checks in code. They act on values (operands) to produce a new result.

Core Categories of Operators

Detailed Breakdown with Examples

1. Arithmetic Operators;-
Used for standard mathematical equations:

++ (Addition): Adds two values or concatenates strings.
-(Subtraction): Subtracts the right value from the left.
- (Multiplication): Multiplies two values.
/(Division): Divides the left value by the right.
%(Remainder/Modulus): Returns the division remainder.
** (Exponentiation): Raises the base to the exponent power.
++ (Increment): Increases an integer value by 1.
-- (Decrement): Decreases an integer value by 1.

javascriptlet total = 10 + 5 * 2; // Evaluates to 20 due to multiplication precedence

2. Assignment Operators

Used to store values inside variables. Shorthand operators allow you to perform an operation and assign the result simultaneously:

+: Simple assignment (x = y)
+=: Add and assign (x = x + y)
-=: Subtract and assign (x = x - y)
*=: Multiply and assign (x = x * y)
/=: Divide and assign (x = x / y)`

let score = 10;
score += 5; // score is now 15

3. Comparison Operators

" width="589" height="487">

Always return a boolean value (true or false).

== (Abstract Equality): Compares values after performing type coercion.
=== (Strict Equality): Compares both the value and the data type without conversion.
!=
(Inequality): Checks if values are not equal.
!== (Strict Inequality): Checks if values or types are not equal.
>/<: Greater than / Less than.
>= / <= : Greater than or equal / Less than or equal.

 javascript

5 == "5";  // true (type coercion converts string to number)
5 === "5"; // false (different types: number vs string)

4. Logical Operators

&& (Logical AND): Returns trueonly if both operands are true.

-||(Logical OR): Returns true if at least one operand is true.

- ! (Logical NOT): Inverts the boolean value (true becomes false).

let accessAllowed = (age >= 18) && (hasTicket === true);

1. What is the operator?

The operator is used to do calculations (i.e., to operate on the numeric values, strings, etc.,). Let us see strings in detail in a future blog.

Example,

let X = 5 + 10;
console.log(X); // 15
let Y = X + 10;
console.log(Y); // 25

Operators in Javascript:-

" width="800" height="327">

Arithmetic Operator:-

Arithmetic operators are used for doing arithmetic operations like addition, subtraction, multiplication, division, etc.,
Arithmetic Operators are +, -, , /, %, *, ++, --
To perform arithmetic operations, we need two values and they can be either numbers, variables, or expressions.

Let us see an example of basic arithmetic operations,

let a = 5;
let b = 6;
let add = a + b; // addition
console.log(add);// 11
let sub = a - b; // subtraction
console.log(sub);// -1
let mul=a * b; // multiplication
console.log(mul);// 30
let div=a / b; // division
console.log(div);// 0.8333333333333334
let modulo = a % b; // modulus
console.log(modulo);// 5

What is ++ and -- operator?

++ is known as Increment Operator.
is known as Decrement Operator.

Increment Operator:-
The increment operator is used to increment the value by 1.

Example;

let a = 5;
a++;
console.log(a);// 6

Decrement Operator:-
The Decrement operator is used to decrement the value by 1.

Example;

let a = 5; a –-; console.log(a);// 4
In the above example, the value stored in the variable ais decremented by one value and so we got the decremented output as 4.

Assignment Operator:-

Assignment operators are used to assigning values to the Javascript Variables.
Assignment operators are =, +=, -=, =, /=, %=, *=
The ‘ = ’ operator is used to assign a value to a variable.

Example:-

let  container = 10;

The ‘ += ’ operator is used to increment the value of a variable with a specified increment value.

Let us take an example to increment the variable what we will do? We will give as

let X = 10;
X = X+2;
console.log(X); // 12

In the above example, we are incrementing the X value by 2. (Note:- the variable declared with the let keyword can be reassigned. So, we are reassigning the value of X to increment it).

Now, we can do the above same thing using the ‘ += ‘ operator, let's see how we can do it,

let X = 10;
X += 2;
console.log(X); // 12

Comparison Operator:-

Comparison operators are used to compare two values and return an output with boolean values such as True or False.
Comparison operators are >, <, <=, >=, ==, !=
Comparison operators are used in Conditional Statements.

example,

let a = 10;
let b = 20;
let c = a>b;
console.log(c); //false
let d = a<b;
console.log(d); //true

In the above example, first, we are checking a condition that a is greater than b according to our value. It checks and gives output as false and next we check that a is less than. It checks and gives output as true.

Identity Operator:-

=== is called identity operator. It is strictly equal to(i.e., it checks or compares exactly whether they are equal or not and returns the output).
They check for their data type and also look-alike.

Logical Operator:-

" width="745" height="420">

The logical Operator evaluates the condition and returns output in True / False.
It is mostly used in Conditional Statements while comparing the two statements at the same time.
Logical operators are ||(OR), &&(AND), !(NOT).

Bitwise Operator:-

Bitwise operators are used for storing the memory size in bits and bytes.
Bitwise Operators are &, |, ~, ^, <<, >>, >>>.
We will see in-detail Bitwise operators with examples in future blogs after completing conditional statements.
In the next blog, we will explore Javascript Datatypes

Data Types in JavaScript

Chandru P — Tue, 02 Jun 2026 12:11:27 +0000

1. Primitive (Basic) Data Types

These are the most fundamental, predefined data types built directly into a computer language. They store simple, single values directly in memory.

Integer (int): Stores whole numbers without decimals, both positive and negative.

Example: 42 or -7.

Floating-Point (float / double): Stores fractional or real numbers containing one or more decimal places.

Example: 3.14 or 0.005.

Character (char): Stores a single letter, number, punctuation mark, or symbol enclosed in quotes.

Example: 'A' or '$'

Boolean (bool):Represents logical values and can only be one of two states.

Example: true or false.
**
2.Non-Primitive (Composite) Data Types**

These are more complex structures created by the programmer or provided by the language to group primitive data types together. Instead of storing a value directly, they often store references or memory addresses to where the data is located.

String: A sequence or collection of text characters grouped together. Example: "Hello World".
Array: A collection of elements of the same data type stored in a fixed, sequential order. Example: [10, 20, 30, 40].
Object / Dictionary: A collection of key-value pairs used to store data in structured formats.

Example: {"name": "Alice", "age": 25}.

What is a Data Type?

A data type is the type of data a variable has, like is it a text or is it a number?

The data type we set a variable to affects what we can do with the variable.
For example, if we have two variables of a number data type, with values 3 and 4, we can use the + operator to add them together, and we get 7:

But, if we store the two values as text string data types instead, as "3" and "4", we get "34" as the result when we use the + operator:

What data types you have available depends on the programming language you are using, but the most common data types are:

String (text)
Integer (whole number)
Float (decimal number)
Boolean (true or false)

The 8 JavaScript Data Types