DEV Community: Alayaki Adedamola

REQUEST METHODS IN EXPRESS.JS

Alayaki Adedamola — Mon, 16 Dec 2024 12:03:33 +0000

Today is another day to share one or two things in my learning journey as regards Backend development.
I'll be sharing about HTTP REQUEST Methods(which is Used to access details about the incoming HTTP request), and i'll be writing about 6 request methods which include;

req.params
req.query
req.body
req.header
req.method
req.url

Now let's dive in and treat them one-by-one

REQ.PARAMS
req.params is an object that contains key-value pairs representing parameters extracted from the URL path. It's particularly useful for dynamic routing, where you define routes with placeholders.
Common Use Cases:

Fetching Specific Resources:

Retrieve a specific user by their ID.
Load a particular product based on its ID and category. Building Dynamic URLs:
Generate URLs for specific resources.
Implementing RESTful APIs: Create routes for CRUD operations (Create, Read, Update, Delete) on resources.

By effectively using req.params, you can create dynamic and flexible web applications with Express.js.

EXAMPLE:

REQ.QUERY req.query is an object in Express.js that contains key-value pairs representing query parameters from the URL. Query parameters are typically used to filter, sort, or paginate data.

Example:
Consider a URL like http://localhost:3000/search?q=javascript&page=2. In this case, req.query would be:

You can access the query parameters using dot notation on the req.query object:

By understanding and effectively using req.query, you can create dynamic and user-friendly web applications that can handle complex search and filtering scenarios.

REQ.BODY req.body is an object that contains the parsed request body. It's commonly used to access data sent from HTML forms, AJAX requests, or API calls.

To access the request body, you'll typically need to use a body-parsing middleware. The most common middleware for this is body-parser.

EXAMPLE:

req.body can be used for Handling form submissions, Processing API requests, Building RESTful APIs.

REQ.HEADER req.headers is an object containing all the headers sent in the HTTP request. Headers provide additional information about the request, such as the client's browser type, preferred language, or authorization credentials.

EXAMPLE:

Common Uses:

Identifying the Client: Determines the user's browser and operating system.
Handling Authentication: Extract authentication tokens from authorization headers.
Customizing Responses: Tailor responses based on the client's preferred language or device type.
Rate Limiting: Implement rate limiting based on the client's IP address or other headers.

By understanding and effectively using req.headers, you can build robust and secure web applications that can adapt to different client environments and implement advanced security features

REQ.METHOD req.method is a property that contains the HTTP method of the incoming request. This property is essential for routing and handling different types of requests, such as GET, POST, PUT, DELETE, etc

EXAMPLE:

By understanding and effectively using req.method, you can build robust and flexible web applications that can handle a variety of HTTP requests and provide appropriate responses.

REQ.URL req.url is a property that contains the URL path of the incoming request. This property is useful for:

Routing: Matching incoming requests to specific routes.
Logging: Logging the requested URL for debugging or analytics.

EXAMPLE:

By understanding and effectively using req.url, you can create robust and secure web applications that can handle a variety of URL patterns and provide appropriate responses.

Sychronous VS Asynchronous Javascript

Alayaki Adedamola — Tue, 03 Dec 2024 19:36:49 +0000

Today, i'll be writing about Sychronous and Asynchronous Javascript.
Fistly, the definitions;
Synchronous tasks happen in order i.e you must finish the first job before moving on to the next. On the flip side, you can execute asynchronous jobs in any order or even simultaneously.

Asynchronous is a non-blocking architecture, so the execution of one task isn’t dependent on another. Tasks can run simultaneously.

Synchronous is a blocking architecture, so the execution of each operation depends on completing the one before it. Each task requires an answer before moving on to the next iteration.

Basically, Javascript is a single-threaded, blocking, sychronous scripting language used to make web pages interactive.
Being single-threaded and blocking means that javascript can only execute one task at a time i.e The program will execute the tasks in sequence, and each task must complete before the next task starts.

Although it’s synchronous by nature, JavaScript benefits from an asynchronous process. Long-running JavaScript functions can make the user interface (UI) or server unresponsive until the function has returned, resulting in a less-than-stellar user experience.
However, there are some instances where users can benefit from blocking programming, for example, when making an online payment.

The benefit of JavaScript is that it offers the best of both worlds: Single-thread and multi-thread, blocking and non-blocking. With this flexibility, programmers can write code in a single programming language instead of two—one for synchronous operations and another for asynchronous operations.

Asynchronous programming enhances the user experience by decreasing the lag time between when a function is called and when the value of that function is returned. Async programming translates to a faster, more seamless flow in the real world.
For example, users want their apps to run fast, but fetching data from an API takes time. In these cases, asynchronous programming helps the app screen load more quickly, improving the user experience.

Synchronous programming, on the other hand, is advantageous for developers. Synchronous programming is much easier to code. It’s well supported among all programming languages, and as the default programming method, developers don’t have to spend time learning something new that could open the door to bugs.

HOW TO CHOOSE BETWEEN ASYNCHRONOUS AND SYNCHRONOUS PROGRAMMING
When deciding which approach to take, consider asynchronous programming adaptable and synchronous programming strict.

Asynchronous programming is the multitasker, moving from one to-do to the other and alerting the system when each task is complete. Synchronous programming functions with a one-track mind, checking off one task at a time in a rigid sequence.

Asynchronous programming allows more things to be done simultaneously and is typically used to enhance the user experience by providing an effortless, quick-loading flow.
Synchronous programming is best utilized in reactive systems. While it is simpler for developers to code and is recognized by every programming language, sync is resource-intensive and can slow things down.

Below, i'll give some examples to better explain synchronous and asynchronous programming.
SYNCHRONOUS PROGRAMMING EXAMPLE

The output for the above code is;
Nissan 2003 true
{ Name: 'Nissan', Year: 2003, Good: true }
Adedamola 33 false
A man called god 300 true

In the above code snippet, all i did was to declare objects and assign values to keys.
you'll notice that the output given is in order with the code written above.. What this implies is that if there is an error with the first object being declared, the remaining code won't run because it's supposed to run synchronously.

ASYNCHRONOUS PROGRAMMING EXAMPLE

The output of the code is;
one
Three
Four
File appended successfully
A new file has been created
Two

This is an example of asynchronous programming because the tasks were not executed in order, and also one task did not wait for another to finish before executing.
Ideally, from the code written above, one should come before two and two should come before three and four. Also, a new file should have been created before the appending, but each task got executed based on the time it took for them to execute.
So it further solidifies the claim that asynchronous programming allows more things to be done simultaneously.

Functions in Javascript

Alayaki Adedamola — Wed, 27 Nov 2024 07:24:29 +0000

I recently just started learning the basics of JavaScript, and I’d like to share something I’ve learnt so far off hand. I’ll be writing about functions in JavaScript.
A function is used to perform a task or calculate a value in JavaScript. It is one of the non-primitive data types that we have in JavaScript(the other two are objects and arrays).

There are two ways we can write a function syntax in JavaScript, and they are;

Function(){}
Const x = ()=>{} (here, x denotes the name of the function we’re declaring

Both ways are syntactically correct.
The second one is called the arrow function.
From the function syntax, we can see that both the parentheses () and curly braces {} are constant. The parentheses is used to accept the parameters, while the curly braces accepts the logic or argument.

It is very important to note that a function isn’t complete if it isn’t called or invoked, else the code will not run.
Below is an example to illustrate everything I’ve said.

Question: write a function sum that takes in two parameters a,b and adds them together.

Solution:
const sum = (a,b) => {
let add = a + b;
console.log(“The sum is: ” + add)
}
sum(3,5)
—————————————————————————————————
The output will be 8.