DEV Community: Agboola Quadri yomike

swapping in js

Agboola Quadri yomike — Thu, 06 Jun 2024 08:53:03 +0000

Swapping two variables with one another is an extremely easy task.

We need a temporary variable to hold the value of one variable (let's say a) while we update that variable (a) to the other variable (b, in this case).

Once the first variable (a) is updated to the second variable (b), the second variable is updated to the temporary variable.

In the code below, we create this temporary variable temp, and complete the swapping of a and b:

var a = 10;
var b = 20;

// Swap a and b
var temp = a;
a = b;
b = temp;
Let's inspect the values of a and b:

a == 20
b == 10

JavaScript Class Constructors

Agboola Quadri yomike — Mon, 03 Jun 2024 17:28:57 +0000

In JavaScript, a class constructor is a special method in a class that is called when an object is created from the class. It is used to initialize the object's properties and set the initial state of the object.

Here is an example of a simple class constructor in JavaScript:

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
}

In this example, the Person class has a constructor that takes two arguments, name and age. When a new Person object is created, the constructor is called, and the name and age properties are set.

For examples:

let person = new Person('John', 30);
console.log(person.name); // Output: John
console.log(person.age); // Output: 30

Here are some key points about class constructors in JavaScript:

The constructor is called when an object is created from the class using the new keyword.
The constructor is responsible for initializing the object's properties.
The constructor can take arguments, which are passed when the object is created.
If no constructor is defined, a default constructor is created automatically.

Here are some more examples of class constructors in JavaScript:

class Car {
  constructor(make, model, year) {
    this.make = make;
    this.model = model;
    this.year = year;
  }
}

let car = new Car('Toyota', 'Corolla', 2020);

class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}

let point = new Point(10, 20);

Difference between Synchronous % Asynchronous

Agboola Quadri yomike — Fri, 31 May 2024 13:50:19 +0000

How code is executed in JavaScript falls into two main categories: synchronous and asynchronous. Understanding these two is key to writing efficient and responsive web applications.

Synchronous

Synchronous code execution happens sequentially, one line at a time. Each line of code waits for the previous line to finish before it starts. Imagine it like waiting in line at a store - you can't move forward until the person in front of you does.

Here's an example of synchronous code:

console.log("I'm first!");

let result = someFunctionThatTakesTime(); // Simulates a long-running task
console.log(result);
In this example, the first line "I'm first!" will be logged to the console, then the program will pause and wait for someFunctionThatTakesTime to finish. Once it does, the result will be logged.

Asynchronous

Asynchronous code execution, on the other hand, doesn't block the main thread. When an asynchronous operation is encountered, like fetching data from a server, the program continues to execute the next line of code. The asynchronous operation runs in the background, and when it's finished, it notifies the program through a callback function.

Here's an example of asynchronous code:

console.log("I'm first!");

fetchDataFromServer(function(data) {
console.log(data);
});

console.log("I'm third!"); // This will be executed before data is fetched

In this example, all three lines are executed one after another. However, the fetchDataFromServer function is asynchronous. So, "I'm first!" and "I'm third!" will be logged immediately, and then the program will continue to wait for the data to be fetched. Once the data is retrieved, the callback function will be executed, and the data will be logged.

Why Asynchronous is Important

Asynchronous programming is essential for creating responsive web applications. If long-running tasks constantly block your code, your UI will become unresponsive and users will have a bad experience. Using asynchronous techniques, you can keep your UI responsive while background tasks are completed.