DEV Community: Karthick (k)

Mastering Functions: Unleashing the Power of Code

Karthick (k) — Fri, 12 Jun 2026 06:47:26 +0000

Q1. Converting a string to Camel Case in JavaScript

CamelCase is a string formatting style in which the first word starts with a lowercase letter and each subsequent word starts with an uppercase letter. It is commonly used in JavaScript to name variables and functions for improved readability.

The first character of the string is converted to lowercase.
Each word after a space has its first character converted to uppercase, and spaces are removed.
This format helps create meaningful and readable variable or function names (e.g., myVariableName).

Functions in JavaScript

Functions in JavaScript are reusable blocks of code designed to perform specific tasks. They allow you to organise, reuse, and modularise code. It can take inputs, perform actions, and return outputs.

Return Statement

The return statement is used to send a result back from a function.
When the return executes, the function stops running at that point.
The returned value can be stored in a variable or used directly.

`function add(a, b) {
return a + b; // returns the sum
}

let result = add(5, 10);
console.log(result);`

JavaScript Hoisting

Hoisting refers to the behavior where JavaScript moves the declarations of variables, functions, and classes to the top of their scope during the compilation phase. This can sometimes lead to surprising results, especially when using var, let, const, or function expressions.

Hoisting applies to variable and function declarations.
Initialisations are not hoisted; they are only declarations.
'var' variables are hoisted with undefined, while 'let' and 'const' are hoisted but remain in the Temporal Dead Zone until initialised.

"Mastering Loops and Functions: A Dive into For Loops and Do-While Structures"

Karthick (k) — Wed, 10 Jun 2026 06:09:40 +0000

JavaScript For Loop

A JavaScript for loop is a control flow statement that allows code to be executed repeatedly based on a condition. It consists of three parts: initialisation, condition, and increment/decrement.

for (statement 1 ; statement 2 ; statement 3){ code here...}

Statement 1: It is the initialisation of the counter. It is executed once before the execution of the code block.

Statement 2: It defines the testing condition for executing the code block.

Statement 3: It is the increment or decrement of the counter & executed (every time) after the code block has been executed.

Flow chart

Example code For Loop

JavaScript do...while Loop

A do...while loop in JavaScript is a control structure where the code executes repeatedly based on a given boolean condition. It's similar to a repeating if statement. One key difference is that a do...while loop guarantees that the code block will execute at least once, regardless of whether the condition is met initially or not.

Entry Controlled loops: In this type of loop, the test condition is tested before entering the loop body. For loops and While Loops are entry-controlled loops.

Exit Controlled Loops: In this type of loop, the test condition is tested or evaluated at the end of the loop body. Therefore, the loop body will execute at least once, irrespective of whether the test condition is true or false. The do-while loop is exit-controlled.

Example code while Loop

*Functions in JavaScript *

point 1. Code Resuability
point 2. Modularity
point 3. Readability
point 4. Maintainability

**Syntax** function functionName(parameters) { // function body // ... }

Function declaration

*Function calling *

As with variables, the identifier used when declaring a function acts as a symbolic name for a value. Referencing a function by identifier alone returns only the function object, and doesn't execute the function it contains:

`function myFunction() {
console.log( "My function has been executed." );
}

myFunction();

"My function has been executed."`

What is a function argument?

A function argument is a value that we pass to the function. The function parameter will represent the value. When I use parameters like name and last name, the values that I will pass, will be called arguments.

JavaScript While Loop

Karthick (k) — Tue, 09 Jun 2026 05:51:40 +0000

Introduction to the JavaScript while loop statement

The while loop executes a block of code as long as a specified condition is true. In JavaScript, this loop evaluates the condition before each iteration and continues running as long as the condition remains true.

Syntax:

while (expression) { // statement }

Basic JavaScript while loop example

The following example uses the while statement to output the odd numbers between 1 and 10 to the console:

Mock Interview

Karthick (k) — Mon, 08 Jun 2026 05:40:06 +0000

Q1.Explain The Concept of Truthy & Falsy Values in JavaScript.

What Are Truthy Values?

Truthy values are values that are evaluated to be true when used in a Boolean context. Simply put, any value that is not explicitly falsy is considered truthy.

What Are Falsy Values?

Falsy values are values that evaluate to false when used in a Boolean. JavaScript has a fixed list of falsy values.

Q2. Variable scope in JavaScript.

Scope and lifetime of variables in Java with examples ...The scope of a variable refers to the specific region of your code where that variable is visible and accessible. It dictates which parts of your program can "see" or manipulate a variable, determining both its accessibility and its lifetime (how long it stays in memory).

Q4.parseInt()

The parseInt() function parses a string argument and returns an integer of the specified radix (the base in mathematical numeral systems).

These are questions,I have written Blogs and read and write

Q3.Default Statement and Q5.Data types in JS and Q6: What is typecasting in JS, and Q7: What are HTML Attributes, and Q8.What is the position: then Relative and Absolute

Self-Introduction Impore:TBD

JavaScript scenario questions (Variables, operators, conditional Statements)

Karthick (k) — Sun, 07 Jun 2026 16:17:52 +0000

Q3. Store a student’s marks in 3 subjects and calculate the total.

let Tamil=90 let English=89 let maths=55 Total=Tamil+English+maths console.log(subjects and calculate total.${Total});

Q4. Swap two numbers without using a third variable.
let A=10 let B=15 A=A+B B=A-B A=A-B console.log(A) console.log(B)
Q5. Create a variable that stores whether a user is logged in or not, and show a welcome message.

` let user_name=" I am Karthick."
let Login=true

    if (Login)
    {
        console.log(`Welcome ${user_name}`)
    }
    else{
        console.log("Please login")
    }

`
Q6. An e-commerce website gives a 10% discount. Calculate the final price.

` let Actual_price=10000
let discount=20

    let Total_price;

    Total_price=Actual_price

    let price=Total_price-Total_price/discount

    let discount_price=price

    console.log("Final price : "+discount_price)

Q7. Check whether a number is even or odd using an operator. let Given_number=89

    if (Given_number%2==0){
        console.log('It is Even Number')
    }
    else{
        console.log('It is odd number')
    }`

Q8.Compare two passwords entered by the user.

` let User_1="Karthick_06";
let User_2="KJkjkhgg_08";

    if (User_1 == User_2){
        console.log('it is True')
    }
    else{
        console.log('it is False')
    }

Q9.A person is eligible to vote if their age is >= 18. Write a condition.

` let person_age=27

    if (person_age>=18)
    {
        console.log('Eligible for vote')
    }
    else{
        console.log('Not Eligible for vote')
    }

Q10. Use logical AND to check: User is logged in, User is admin, then allow dashboard access. let userlogin=true
let user="Admin"

    if (userlogin && user == "Admin"){
        console.log('Welcome to Dashbord')
    }
    else{
        console.log('Access Deneid')
    }

Q11.Create a function that calculates the total cart amount.

` function cart_total(){
let item1=500;
let item2=1000;
let item3=300;

        let total=item1+item2+item3
        console.log("Total amount :",total)
    }`

Q12. Create a function to greet a user by name.

function greet(username){ console.log("Welcome"+" "+username+"!") } greet("Karthick")

Q13.Create a function to convert Celsius to Fahrenheit.

` function converts(celsius){
return (celsius* 9/5)+32;
}

    let celsius=42;
    let fahrenhint=converts(celsius);
    console.log(fahrenhint)`

Q14.Create a function that returns the largest of two numbers.
function largest(n1,n2){ if (n1>n2){ return n1; } else if (n2>n1){ return n2; } else{ return ("Both are the same") } }

JavaScript scenario questions (Variables, operators, conditional Statements)

Karthick (k) — Sat, 06 Jun 2026 15:36:09 +0000

Q1.You are building a login system. Store username and password in variables and check whether both are filled.

console.log('Login System')

        let username="Karthi_09"
        let password="Karthi_09"

        if (username && password)
        {
            console.log('Login Successfully');
        }
        else{
            console.log('Both are filled')
        }

Q2. Create variables to store a product’s name, price, and stock. Print a message like:iPhone costs ₹60000, and only 5 are left in stock.

        let Product_name="iphone"
        let product_price="$60000"
        let stock=5

        console.log(`The ${Product_name} costs ${product_price} and only ${stock} left in stock`)

Q3. Store a student’s marks in 3 subjects and calculate the total.

        let Tamil=90
        let English=89
        let maths=55
        Total=Tamil+English+maths
        console.log(`subjects and calculate total.${Total}`);

Become a pro in JavaScript

Karthick (k) — Fri, 05 Jun 2026 06:52:27 +0000

Q1.JavaScript console.log() Method.

In JavaScript, the console.log() method is a built-in JavaScript function that outputs messages to the console, which is a special area in web browsers or runtime environments for developers to view information about their code.

It is primarily used for

Debugging code
Inspecting variables
Tracking the flow of execution
Logging errors or warnings

console.log("");

Q2.Exponentiation ()**

The exponentiation (**) operator returns the result of raising the first operand to the power of the second operand. It is equivalent to Math.pow(), except it also accepts BigInts as operands.

Q3.Operator precedence

Operator precedence determines how operators are parsed with respect to each other. Operators with higher precedence become the operands of operators with lower precedence.

Q4. What are chaining assignments in JavaScript?

Chaining assignments in JavaScript is a syntax pattern that allows you to assign a single value to multiple variables in a single line of code.

let a, b, c; a = b = c = 10;

Q5.Conditional (ternary) operator:

The conditional (ternary) operator is the only JavaScript operator that takes three operands: a condition followed by a question mark (?), then an expression to execute if the condition is truthy, followed by a colon (:), and finally the expression to execute if the condition is falsy. This operator is frequently used as an alternative to an if...else statement.

`Syntax

(condition) ? expression1 : expression2
`
Q5.Scope of Variables in JavaScript

Global Scope

A global variable refers to a variable that is declared outside any function or block, so it can be used anywhere in the program, both inside functions and in the main code.

`// Global Variable accessed from within a function
const x = 10;

function fun1() {
console.log(x);
}

fun1();`

Local Scope

A local variable is a variable declared inside a function, making it accessible only within that function. It cannot be used outside the function.

Functions are objects and can be assigned to variables.

`function fun2(){

// This variable is local to fun2() and 
// cannot be accessed outside this function
let x = 10;
console.log(x);

}

fun2();
`

Q6.The break Statement

The break statement is used to exit a loop when a certain condition is satisfied. It is commonly used when searching for a specific value in an array or when an early exit from a loop is required.

`Syntax

break;`

Q7.The Continue statement

The continue statement skips the current iteration of the loop and moves to the next iteration without terminating the loop.

`Syntax

continue;`

Q8 .How the switch Statement Works

In JavaScript, a *switch statement * is a control-flow mechanism that evaluates an expression and matches its value against multiple case clauses to execute specific code blocks.

`const fruit = "Apple";

switch (fruit) {
case "Banana":
console.log("Bananas are yellow.");
break;
case "Apple":
console.log("Apples are red or green.");
break;
default:
console.log("Unknown fruit.");
}
// Output: "Apples are red or green."
`
Key Rules for Using default

In JavaScript, the default clause in a switch statement acts as a fallback that executes when none of the specified case values matches the given expression. It serves the same purpose as the final else block in an if-else chain

`const expression = "orange";

switch (expression) {
case "apple":
console.log("Apples are $1.00");
break;
case "banana":
console.log("Bananas are $0.50");
break;
default: // Executes if expression is neither "apple" nor "banana"
console.log("Item not found");
break;
}`

Conditional branching: if, '?'

Karthick (k) — Thu, 04 Jun 2026 06:29:09 +0000

Q1, JavaScript - Conditional Statements

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.

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.

if (condition) { // code runs if the condition is true }
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.

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.

Q2.Explain The Concept of Truthy & Falsy Values in JavaScript

In JavaScript, truthy and falsy values are concepts related to Boolean evaluation. Every value in JavaScript has an inherent boolean "truthiness" or "falsiness," which means they can be implicitly evaluated to true or false in boolean contexts, such as in conditional statements or logical operations.

What Are Truthy Values?

Truthy values are values that are evaluated to be true when used in a Boolean context. Simply put, any value that is not explicitly falsy is considered truthy.

These are some truthy values

Non-zero numbers: 42, -1, 3.14
Non-empty strings: "hello", "0", " "
Objects and arrays: {}, []
Functions: function() {}
Dates: new Date()
Symbols: Symbol()
BigInt values other than 0n: 10n

if (42) console.log("This is truthy!"); if ("hello") console.log("Non-empty strings are truthy!"); if ({}) console.log("Objects are truthy!");

What Are Falsy Values?

Falsy values are values that evaluate to false when used in a Boolean. JavaScript has a fixed list of falsy values

false
0 (and -0)
0n (BigInt zero)
"" (empty string)
null
undefined
NaN
document. all (used for backward compatibility)

if (0) console.log("This won't run because 0 is falsy."); if ("") console.log("This won't run because an empty string is falsy."); if (null) console.log("This won't run because null is falsy.");

JavaScript Tutorial

Karthick (k) — Wed, 03 Jun 2026 05:49:28 +0000

Q1.Primitive and Non-primitive data-types in JavaScript.

Primitive Data Types.
Primitive data types are the built-in data types provided by JavaScript. They represent single values and are immutable, meaning their values cannot be changed directly after creation. JavaScript supports the following primitive data types:
Non-primitive Data Types
Non-primitive data types, also known as reference types, are objects and derived data types. They can store collections of values or more complex entities. The two key non-primitive data

Q2.JavaScript Number parseInt() Method.

The parseInt() method parses a value by converting it to a string and returns the first integer found. It also accepts an optional radix parameter that specifies the base of the numeral system.

Converts a string into an integer value.
Supports different number systems using the radix parameter.
Stops parsing when a non-numeric character is encountered.

Q3:JavaScript Number parseFloat() Method.

The JavaScript parseFloat() method accepts a string and converts it to a floating-point number. If the string does not contain a numerical value, or if the first character of the string is not a number, then it returns NaN, i.e., not a number. It actually returns a floating-point number parsed up to that point where it encounters a character that is not a Number.

Q4:Post-Increment (x++) || Pre-Increment (++x) && Pre-Decrement (--x) || Post-Decrement (x--).

Post-Increment (x++):

The post-increment operator evaluates the current expression using the variable's original value, and then adds 1 to the variable right after.

`let x = 5;
let y = x++; // y gets the original value (5), then x becomes 6

console.log(y); // Output: 5
console.log(x); // Output: 6
`

Pre-Increment (++x):

The pre-increment operator adds 1 to the variable first, and then returns the newly updated value to the expression

`let x = 5;
let y = ++x; // x becomes 6 first, then y gets the new value (6)

console.log(y); // Output: 6
console.log(x); // Output: 6
`

Pre-Decrement (--x):

In a prefix operation, JavaScript updates the variable instantly before evaluating the rest of the statement

`let x = 5;

// Decrements x to 4, then returns 4 to be assigned to 'result'
let result = --x;

console.log(result); // Output: 4
console.log(x); // Output: 4`

Post-Decrement (x--)

In a postfix operation, JavaScript saves the original value to use in the expression, then subtracts 1 from the variable behind the scenes

`let y = 5;

// Returns the original value (5) to 'result', then decrements y to 4
let result = y--;

console.log(result); // Output: 5 (the old value)
console.log(y); // Output: 4 (the updated value)`

Introduction - JavaScript

Karthick (k) — Tue, 02 Jun 2026 06:45:37 +0000

Q1. Client-side scripting :

Web browsers execute client-side scripting. It is used when browsers have all the code. Source code is used to transfer from the web server to the user's computer over the internet and run directly in browsers. It is also used for validations and functionality for user events.

Q2. Server-side scripting :

Web servers are used to execute server-side scripting. They are basically used to create dynamic pages. It can also access the file system residing on the web server. A server-side environment that runs on a scripting language is a web server.

Q3.What is Localhost?

In computer networking, a host means a “server”. Just like you can put a website on the internet by hosting it on a server, you can make your own computer that serves as a server. This connection is called loopback. The IP address for that loopback is 127.0.0.1.

Q4.JavaScript Data Types

JavaScript data types define what kind of values a variable can hold and how those values behave in a program. They determine how data is stored in memory and how operations like comparison, calculation, and conversion work.

Q5.Here is a list of JavaScript Engines for major Internet browsers:

V8 — JavaScript Engine developed by Google for Chrome
SpiderMonkey — The JavaScript Engine used by Mozilla Firefox
JavaScriptCore — Developed by Apple for Safari
Rhino — Managed by Mozilla Foundation for Firefox
Chakra — A JavaScript Engine for Microsoft Edge
JerryScript — A JavaScript Engine employed for the Internet of Things (IoT).

Q8.JavaScript Operators

JavaScript operators are symbols or keywords used to perform operations on values and variables. They are the building blocks of JavaScript expressions and can manipulate data in various ways.

&-->JavaScript Arithmetic Operators

Arithmetic Operators perform mathematical operations such as addition, subtraction, and multiplication.

const sum = 5 + 3; // Addition const diff = 10 - 2; // Subtraction const p = 4 * 2; // Multiplication const q = 8 / 2; // Division console.log(sum, diff, p, q);
&--> JavaScript Assignment Operators

Assignment operators are used to assign values to variables. They can also perform operations like addition or multiplication while assigning the value.

let n = 10; n += 5; n *= 2; console.log(n);
&--> JavaScript Comparison Operators

Comparison operators compare two values and return a Boolean (true or false). They are useful for making decisions in conditional statements.

console.log(10 > 5); console.log(10 === "10");

&--> JavaScript Logical Operators

Logical operators are mainly used to perform logical operations that determine equality or difference between values.

const a = true, b = false; console.log(a && b); // Logical AND console.log(a || b); // Logical OR

&--> JavaScript Bitwise Operators

Bitwise operators perform operations on binary representations of numbers.

const res = 5 & 1; // Bitwise AND console.log(res);

&--> JavaScript Ternary Operator

The ternary operator is a shorthand for conditional statements. It takes three operands.

const age = 18; const status = age >= 18 ? "Adult": "Minor"; console.log(status);

&--> JavaScript Comma Operator

Comma Operator (,) mainly evaluates its operands from left to right sequentially and returns the value of the rightmost operand.

let n1, n2 const res = (n1 = 1, n2 = 2, n1 + n2); console.log(res);

&--> JavaScript Unary Operators

Unary operators operate on a single operand (e.g., increment, decrement).

`let x = 5;

console.log(+x);
console.log(-x);

console.log(++x);
console.log(--x);

console.log(!x);`

&--> JavaScript Relational Operators

JavaScript Relational operators are used to compare their operands and determine the relationship between them. They return a Boolean value (true or false) based on the comparison result.

const obj = { length: 10 }; console.log("length" in obj); console.log([] instanceof Array);

&--> JavaScript BigInt Operators

BigInt operators allow calculations with numbers beyond the safe integer range.

const big1 = 123456789012345678901234567890n; const big2 = 987654321098765432109876543210n; console.log(big1 + big2);
&--> JavaScript String Operators

JavaScript String Operators include concatenation (+) and concatenation assignment (+=), used to join strings or combine strings with other data types.

const s = "Hello" + " " + "World"; console.log(s);

&--> JavaScript Chaining Operator (?.)

The optional chaining operator allows safe access to deeply nested properties without throwing errors if the property doesn’t exist.

const obj = { name: "Aman", address: { city: "Delhi" } }; console.log(obj.address?.city); console.log(obj.contact?.phone);

Q8:typeof

The typeof operator returns a string indicating the type of the operand's value.

Q9:JavaScript Type Conversion

In JavaScript, Type Conversion can be defined as converting the data type of the variables from one type to another manually by the programmer(explicitly) or automatically by JavaScript(implicitly).

Implicit Type Conversion (Coercion): Implicit Type Conversion occurs automatically in JavaScript.

Explicit Type Conversion: Explicit Type Conversion occurs when the programmer manually changes the type of the variables using the functions Number(), String(), and Boolean().

JavaScript Introduction

Karthick (k) — Mon, 01 Jun 2026 06:27:07 +0000

Q1.ASCII Values Alphabets ( A-Z, a-z & Special Character Table )

ASCII (American Standard Code for Information Interchange) is a character encoding standard that assigns unique numeric values to letters, digits, punctuation marks and symbols. Since computers work only with binary data (0s and 1s), ASCII acts as a bridge by converting human-readable characters into machine-readable numbers.

Q2.Binary Number System

The Binary Number System, also known as the base-2 system, uses only two digits, '0' and '1', to represent numbers. It forms the fundamental basis for how computers process and store data. This base-2 system is the backbone of how computers process and store information, representing everything from text to images as sequences of 0s and 1s.

Q3 Compiler and Interpreter

Compiler:

A compiler is a software program that transforms high‐level source code that is written by a developer in a high‐level programming language into low-level object code (binary code) in machine language, which can be understood by the processor. The process of converting high‐level programming into machine language is known as compilation.

Interpreter:

An interpreter transforms or interprets a high‐level programming code into code that can be understood by the machine (machine code) or into an intermediate language that can be easily executed as well. The interpreter reads each statement of code and then converts or executes it directly.

Q4.What is a byte?

In most computer systems, a byte is a unit of data that is eight binary digits long. A byte is the unit most computers use to represent a character, such as a letter, number or typographic symbol.

Q5.Introduction to JavaScript

JavaScript is a versatile, dynamically typed programming language that brings web pages to life by making them interactive. It is used for building interactive web applications and supports both client-side and server-side development.

Interpreted language: Code is executed line by line.
Dynamically typed: Variable types are determined at runtime.
Single-threaded: Executes one task at a time (but supports asynchronous operations).

Q6.JavaScript Variables

Variables in JavaScript are used to store data values. They can be declared in different ways depending on how the value should behave.

Variables can be declared using var, let, or const.
JavaScript is dynamically typed, so types are decided at runtime.
You don’t need to specify a data type when creating a variable

Declaring Variables in JavaScript

ES6 Introduction: let and const were introduced to provide safer alternatives for declaring variables.
Scope: let and const are block-scoped (limited to { } block) or global-scoped, reducing errors compared to var.

var keyword var is a keyword in JavaScript used to declare variables; it is Function-scoped and hoisted, allowing redeclaration, but it can lead to unexpected bugs.

var a = "Hello Geeks"; var b = 10; console.log(a); console.log(b);

let keyword

let is a keyword in JavaScript used to declare variables,and it is Block-scoped and not hoisted to the top, suitable for mutable variables

let a = 12 let b = "gfg"; console.log(a); console.log(b);

const keyword

const is a keyword in JavaScript used to declare variables, and it is Block-scoped, immutable bindings that can't be reassigned, though objects can still be mutated.

const a = 5 let b = "gfg"; console.log(a); console.log(b);

Q7.Core Key Features of ES6

ES6, which stands for ECMAScript 6, is the sixth major edition of the ECMAScript standard that defines how JavaScript works. Released in June 2015 and officially named ECMAScript 2015, it introduced the most significant syntax updates and features to JavaScript since its inception

CSS variable

Karthick (k) — Sat, 30 May 2026 17:11:07 +0000

Q1.padding: var(--section-pad);

This applies internal spacing (padding) to an element using a CSS variable. Instead of writing a fixed size like 20px or 2rem, the browser checks your CSS for-- section-pad (usually defined at the top of your stylesheet) and uses that specific value.

Q2. What are:: before and:: after?

These are CSS pseudo-elements. They allow you to create virtual boxes in your HTML that are styled by CSS but don't actually exist in your physical HTML file.
.::before creates a virtual element before the actual content of your target box.::after creates a virtual element after the actual content. Crucial Rule: They require the content: ""; property to work at all (even if the quotation marks are empty).
Common Uses: CSS variable, adding decorative icons or text before a heading.Creating background shapes, underlines, or borders without adding extra

tags to your HTML