DEV Community: Haryniramesh

Template Literals

Haryniramesh — Thu, 29 May 2025 17:20:23 +0000

Types of Literals in JavaScript

1. String Literals

const name1 = 'Alice';
const name2 = "Bob";
const greeting = Hello; // Template literal

2. Numeric Literals

const age = 25; // Integer
const pi = 3.14; // Floating point
const hex = 0xFF; // Hexadecimal (255)
const binary = 0b1010; // Binary (10)
const octal = 0o12; // Octal (10)

3. Boolean Literals

const isTrue = true;
const isFalse = false;

4. Array Literals

const fruits = ['apple', 'banana', 'cherry'];

5. Object Literals

const person = {
name: 'John',
age: 30
};

6. Null Literal

const empty = null;

7. Undefined Literal

undefined is usually a value assigned by JavaScript when a variable is declared but not initialized.

let x;
console.log(x); // undefined

8. Regular Expression Literal

const pattern = /ab+c/;

9. Template Literals (Special type of string literal)

const user = 'Jane';
const message = Hello, ${user}!; // String + Expression

✅ 1. Template Literals

Used to embed variables and expressions in strings.

const name = "Alice";
const age = 25;
const message = My name is ${name} and I am ${age} years old.;
console.log(message);

✅ 2. HTML Element (for DOM templates)

In web development, the HTML element holds HTML that you can clone and insert into the DOM using JavaScript.

const template = document.getElementById("card-template");
const clone = template.content.cloneNode(true);
clone.querySelector(".title").textContent = "Product Name";
clone.querySelector(".description").textContent = "Product Description";
document.body.appendChild(clone);

✅ 3. Template Functions or Rendering Templates

You can create your own template functions to build strings or HTML based on data:

function renderUser(user) {
return <div class="user"> <h3>${user.name}</h3> <p>Age: ${user.age}</p> </div>;
}

const user = { name: "Bob", age: 30 };
document.body.innerHTML = renderUser(user);

JAVASCRIPT

Haryniramesh — Wed, 28 May 2025 18:41:37 +0000

Why use functions?

Reusability: Write code once and use it multiple times.
Modularity: Break down complex problems into smaller, manageable pieces.
Readability: Makes your code easier to understand and maintain.
Avoid Repetition: Prevents writing the same code over and over.

Ways to Define Functions in JavaScript

There are several ways to define functions in JavaScript, each with its own nuances:

Function Declarations 
Function Expressions 
Arrow Functions 
Immediately Invoked Function Expressions

1. Arrow Function
const add = (a, b) => a + b;

2. Anonymous Function

const greet = function(name) {
return "Hello, " + name;
};

🧪 Example: Add Two Numbers

function add(a, b) {
return a + b;
}

Usage:

console.log(add(5, 3)); // Output: 8

⌨️ Form and Input Handling

const form = document.forms[0];

input.value

const name = document.getElementById("username").value;

Static variable

Haryniramesh — Wed, 28 May 2025 17:34:23 +0000

Static Variables in Java

Static variables in Java are class-level variables that are shared among all instances of the class. Here are the key characteristics:

Key Features

Class-level storage: Belongs to the class rather than any specific instance
Single copy: Only one copy exists regardless of how many objects are created
Shared access: All instances share the same static variable
Memory allocation: Created when the class is loaded and destroyed when the class is unloaded

Declaration Syntax

class MyClass {
    static int count;  // static variable
    // ...
}

When to Use Static Variables

When you need a variable common to all objects of a class
For constants (usually combined with final)
For maintaining counts or other shared states across instances

Important Notes

Access: Can be accessed using either:
- Class name: MyClass.count
- Instance reference: obj.count (not recommended)
Initialization:
- Default values (0, null, false etc.) if not initialized
- Can be initialized at declaration or in static blocks
Thread Safety: Static variables are not thread-safe by default - need synchronization in multi-threaded environments

Example

public class Employee {
    static int employeeCount = 0;  // static variable

    public Employee() {
        employeeCount++;  // increments for each new Employee created
    }

    public static void main(String[] args) {
        new Employee();
        new Employee();
        System.out.println("Total employees: " + Employee.employeeCount);  // Output: 2
    }
}

Static variables are useful for maintaining shared state across all instances of a class, but should be used judiciously to avoid unintended side effects.

Using While Loop

Haryniramesh — Thu, 17 Apr 2025 17:48:59 +0000

Program:

public class Multiples{

public static void main(String args[])
{
int num=1;
int meeting_point=0;
int no1=21, no2=43;

while(true)
{
if(num%no1==0 && num%no2==0)
{
meeting_point+=1;
if(meeting_point==3)
{
System.out.println("Meeting point:" + num);
break;
}
}
num+=1;
}
}

}

Output:

Meeting point:2709

Variables in Java

Haryniramesh — Thu, 17 Apr 2025 17:43:42 +0000

Static Variables in Java

Static variables in Java are class-level variables that are shared among all instances of the class. Here are the key characteristics:

Key Features

Class-level storage: Belongs to the class rather than any specific instance
Single copy: Only one copy exists regardless of how many objects are created
Shared access: All instances share the same static variable
Memory allocation: Created when the class is loaded and destroyed when the class is unloaded

Declaration Syntax

class MyClass {
    static int count;  // static variable
    // ...
}

When to Use Static Variables

When you need a variable common to all objects of a class
For constants (usually combined with final)
For maintaining counts or other shared states across instances

Important Notes

Access: Can be accessed using either:
- Class name: MyClass.count
- Instance reference: obj.count (not recommended)
Initialization:
- Default values (0, null, false etc.) if not initialized
- Can be initialized at declaration or in static blocks
Thread Safety: Static variables are not thread-safe by default - need synchronization in multi-threaded environments

Example

public class Employee {
    static int employeeCount = 0;  // static variable

    public Employee() {
        employeeCount++;  // increments for each new Employee created
    }

    public static void main(String[] args) {
        new Employee();
        new Employee();
        System.out.println("Total employees: " + Employee.employeeCount);  // Output: 2
    }
}

Static variables are useful for maintaining shared state across all instances of a class, but should be used judiciously to avoid unintended side effects.

Static and Non Static Members

Haryniramesh — Tue, 01 Apr 2025 16:54:58 +0000

1.Static Members (Class-Level)

Defined using static keyword.
Belongs to the class rather than an instance of the class.
Shared among all objects of the class.
Can be accessed without creating an instance of the class.

Example:

class Example {

static int count = 0; // Static variable
static void displayCount() { // Static method
    System.out.println("Count: " + count);
}

}

public class Main {
public static void main(String[] args) {
Example.count = 5; // Accessing static variable without creating an object
Example.displayCount(); // Calling static method
}
}

Output:

Count: 5

2.Non-Static Members (Instance-Level)

Do not use static keyword.
Each object of the class gets its own copy.
Requires an object to access.

Example:

class Example {
int count = 0; // Non-static variable

void displayCount() { // Non-static method
    System.out.println("Count: " + count);
}

}

public class Main {
public static void main(String[] args) {
Example obj1 = new Example();
Example obj2 = new Example();

    obj1.count = 10;
    obj2.count = 20;

    obj1.displayCount(); // Output: Count: 10
    obj2.displayCount(); // Output: Count: 20
}

}

Output:

Count: 10
Count: 20

When to Use Static?

✅ Use static when the data is shared across all instances (e.g., utility methods, constants).
❌ Avoid static when each object should maintain its own data (e.g., object attributes).

When to Use Non-Static?

✅ When each object should have different values.
✅ When each object should have its own behavior.
✅ When OOP features (Encapsulation, Polymorphism, Inheritance) are needed.
✅ When memory should only be used when an object exists.
❌ When data should be shared among all objects (e.g., static int totalEmployees).
❌ When methods do not depend on object variables (e.g., static int square(int x)).
❌ When memory efficiency matters (e.g., static configurations).
❌ When working with constants (e.g., static final double PI).
❌ When object creation is unnecessary (e.g., utility/helper methods).

PostgreSQL Joins

Haryniramesh — Wed, 26 Mar 2025 05:52:18 +0000

1. INNER JOIN

An INNER JOIN returns rows when there is at least one match in both tables. If there is no match, the row will not appear in the result set.

SELECT employees.name, departments.name
FROM employees
INNER JOIN departments
ON employees.department_id = departments.id;

2. LEFT JOIN (or LEFT OUTER JOIN)

A LEFT JOIN returns all the rows from the left table and the matched rows from the right table. If there is no match, NULL values will be returned for columns from the right table.

SELECT employees.name, departments.name
FROM employees
LEFT JOIN departments
ON employees.department_id = departments.id;

3. RIGHT JOIN (or RIGHT OUTER JOIN)

A RIGHT JOIN returns all rows from the right table and the matched rows from the left table. If there is no match, NULL values will be returned for columns from the left table.

SELECT employees.nae, departments.name
FROM employees
RIGHT JOIN departments
ON employees.department_id = departments.id;

4. FULL JOIN (or FULL OUTER JOIN)

A FULL JOIN returns rows when there is a match in one of the tables. It returns NULL for the non-matching rows in both tables.

SELECT employees.name, departments.name
FROM employees
FULL JOIN departments
ON employees.department_id = departments.id;

FUNCTIONS IN JAVASCRIPT

Haryniramesh — Thu, 06 Mar 2025 08:34:28 +0000

1.document.getElementsByClassName(className);

It returns a live HTML Collection,if the DOM changes the HTML Collection will automatically update.
It returns a collection of elements with the given class name, so we need to loop them.
If no elements match, it returns an empty HTML Collection.

2.document.getElementsByTagName(tagName);

It returns a live HTML Collection, meaning if the document is updated the HTML Collection will be updated automatically.
It matches all elements with the specified tag name, and you can loop through the returned collection or access specific elements by index.
If no elements match, it returns an empty HTML Collection.

3.Math.sqrt(x);

The square root function is only defined for non-negative real numbers, so passing a negative number to Math.sqrt() will return NaN.
For complex numbers JavaScript does not directly handle them using Math.sqrt(). You would need a different approach or library for that.

4.Math.abs(x);

It is a built-in method that returns the absolute value of a number.
The absolute value of a number is its non-negative value, meaning it removes any negative sign.

5.document.getElementById(id);

It is a built-in method used to retrieve an element from the DOM by its ID attribute.
This method is one of the most common ways to interact with specific elements in an HTML document.

6.document.write(text);

It is a method used to write text or HTML content directly to the document during the page's loading process.