DEV Community: Sosanya Esther

Response methods

Sosanya Esther — Sat, 15 Feb 2025 00:03:11 +0000

What are Response Methods?
The Response object (response) provides the HTTP response that an Express app sends when it receives an HTTP request.

Different Types of Response Methods
1.res.send(): Most people are already familiar with the res.send() method. You can answer HTTP requests with a variety of data types using res. send().
2.res.json(): It is used for sending a JSON response. This function uses JSON.stringify() to transform the parameter into a JSON string and sends a response (with the correct content type).
3.res.status(): Represents the status of the response, res. status defines the HTTP response code. If an unidentified status code is provided, the response body will just contain the code's numeric value.
Each code will represent a different response state.
-5xx: Server error
-4xx: Error in clients
-3xx: Redirects
-2xx: Success
-1xx : Information
4.res.download(): The file at the path is transferred as an "attachment." Browsers will typically prompt the user to download. The path argument is used by default to derive the Content-Disposition header "filename=" parameter, although this can be modified with the filename parameter. If the path is relative, it will be based on the process's current working directory or the root option, if specified.
5.res.end(): The response procedure will end using this method. This method was inspired by Node core, notably the response. end() method of HTTP.ServerResponse. Use to swiftly terminate the response with no data. If you want to send the response with data, instead use res. send() and res.json().
6.res.send file(): Transfers the file at the specified path. Sets the Content-Type response HTTP header field based on the extension of the filename. The path should be a complete path to the file unless the root option is provided in the options object.

Differences between req.query,req.param and req.body

Sosanya Esther — Fri, 14 Feb 2025 23:39:39 +0000

The req.query property allows you to access the query parameters from the URL of an incoming HTTP request.
The req.params property is an object containing properties mapped to the named route “parameters”.
The req.body property contains key-value pairs of data submitted in the request body. By default, it is undefined and is populated when you use a middleware called body-parsing such as express.urlencoded() or express.json().

In summary,the difference is that;req.params when you have dynamic segments in your route patterns, req.query when you want to retrieve data from the query string, and req.body for data sent in the request body.

Http methods and Codes

Sosanya Esther — Wed, 29 Jan 2025 17:15:50 +0000

What is the HTTP?
The Hypertext Transfer Protocol (HTTP) is the foundation of communication between clients and servers on the web. HTTP methods play a crucial role in defining how this communication occurs. Each method has a specific purpose and understanding their nuances is essential for effective web development.

What are HTTP Methods?
HTTP methods, which are also known as HTTP verbs, are responsible for defining the actions that can be performed on resources identified by Uniform Resource Identifiers (URIs)

HTTP defines several methods, each serving a specific purpose in handling resource requests and responses. The most common HTTP methods include: GET, POST, PUT, DELETE, HEAD, OPTIONS, CONNECT, and TRACE. The GET method retrieves information from the server, while the POST method sends data to the server to create, update, or delete resources. The PUT method is used to update a resource, and the DELETE method is used to delete a resource. The HEAD method retrieves only the header information of a resource, while the OPTIONS method retrieves the available methods that can be used on a resource. The CONNECT method establishes a network connection, and the TRACE method echoes the received request back to the client.
GET Method:
The GET method is one of the simplest and most commonly used HTTP methods. It is used to request data from a specified resource. GET requests are idempotent, meaning multiple identical requests should have the same effect as a single request. The data is included in the URL as parameters. Requests using GET should only retrieve data.

Example:

POST Method:
POST is used to submit data to be processed to a specified resource. Unlike GET, POST requests do not append data to the URL; instead, they include the data in the request body. This makes it suitable for sending large amounts of data or sensitive information. The POST method is used when you want to send some data to the server, for example, file update, form data, etc. The POST method often causes a change in state or side effects on the server.

Example:

PUT Method:
PUT is used to update a resource on the server. It requires the client to send the entire updated resource representation. If the resource does not exist, PUT can create a new resource with the provided data. In RESTful web services, the HTTP method PUT is typically used for both creating new data and updating existing data.

Example:

DELETE Method:
DELETE is used to remove a resource from the server. It is an idempotent method, meaning repeated DELETE requests will have the same effect as a single request.

Example:

HEAD Method:
The HEAD method is similar to GET, but it retrieves only the headers of a resource without the actual data. It is useful when you need to check the headers before downloading the entire resource.

Example:

OPTIONS Method:
The OPTIONS method is used to determine the communication options available for a given resource. It helps the client understand which HTTP methods and headers are supported.

Example:

PATCH Method:
PATCH is used to apply partial modifications to a resource. It is more efficient than PUT when updating only specific fields of a resource.

Example:

HTTP status codes are three-digit codes that indicate the outcome of an API request. They are included in the API’s response to the API client, and they include important information that helps the client know how to proceed.
What are the different types of HTTP status codes?
HTTP status codes are grouped into five classes, each beginning with a number that represents the type of response. The classes are:

1xx informational responses
These codes indicate that the server has received the request and is processing it. They are primarily used to manage communication between the client and server during the early stages of a request-response cycle. Some examples of this type of code are:

100 Continue: This status code indicates that the initial part of the request has been received and the server would like the client to send the rest of it.
101 Switching Protocols: This status code is used to inform the client that the server is changing the protocol that is being used in the connection.
102 Processing: This status code is an interim response that indicates the server is still processing the request.

2xx success responses
These codes indicate that the client’s request was successfully received, understood, and processed by the server. Some of the most common 200 responses are:

200 OK: This status code indicates that the request was successful, and the server returned the requested data.
201 Created: This status code means that the request was successful, and the server created a new resource.
204 No Content: This status code indicates that the request was successful, but the server did not return any data.

3xx redirection responses
These codes indicate that the client needs to take additional actions to fulfill the request. They are often used when the requested resource has moved to a different location. Some examples include:

301 Moved Permanently: This status code indicates that the requested resource has been permanently moved to a new URL. Clients should respond by updating their bookmarks and links to point to the new URL, and search engines should update their indexes with the new location.
303 See Other: This status code indicates that the response is available at a different URL, and the client should perform a GET request to that URL to retrieve the resource.

4xx client error responses
These codes indicate that there was an issue with the client’s request, such as a mistyped URL or invalid credentials. The most common 4xx responses include:

400 Bad Request: This status code indicates that the request was malformed or invalid.
401 Unauthorized: This status code lets the client know that it is not authorized to access the requested resource.
403 Forbidden: This status code communicates that the client is authenticated but not authorized to access the requested resource.
404 Not Found: This status code indicates that the requested resource was not found on the server.

5xx server error responses
These codes, which indicate that the server encountered an error while trying to fulfill the client’s request, include:

500 Internal Server Error: This generic error code indicates the server encountered an unexpected condition that prevented it from fulfilling the request.
502 Bad Gateway: This status code indicates that a server acting as a gateway or proxy received an invalid response from an upstream server.
503 Service Unavailable: This status code is returned when the server is temporarily unable to handle the request. It’s often seen during periods of increased traffic or when the server is undergoing maintenance.

Http methods and codes

Sosanya Esther — Wed, 29 Jan 2025 16:45:41 +0000

HTTP methods are used to indicate the action an API client would like to perform on a given resource. Each HTTP method maps to a specific operation, such as creating, reading, updating, or deleting a resource, and an HTTP method must be included with every request to a REST API.
HTTP protocol works by clients sending requests to the servers and servers responding to the requests. We do CRUD operations (Create, Read, Update, Delete) by sending HTTP requests with different HTTP methods, sometimes called HTTP verbs. GET and POST are the most frequently used HTTP methods, but more HTTP methods are to learn. This article will go through different HTTP methods and how to use them when building and using web APIs.
9 HTTP methods you should know about
1.GET Method
If we want to retrieve data from a resource like websites, servers or APIs, we send them a GET Request. For example, we send a GET request to the server if we want a list of our customers or a specific customer.
Since the GET method should never change the data on the resources and just read them(read-only), it is considered a Safe Method. Additionally, the Get method is idempotent.

How to test an API with a GET method?
When we want to test an API, the most popular method that we would use is the GET method. Therefore, We expect the following to happen.

If the resource is accessible, the API returns the 200 Status Code, which means OK.
Along with the 200 Status Code, the server usually returns a response body in XML or JSON format. So, for example, we expect the [GET] /members endpoint to return a list of members in XML or JSON.
If the server does not support the endpoint, the server returns the 404 Status Code, which means Not Found.
If we send the request in the wrong syntax, the server returns the 400 Status Code, which means Bad Request.

2.POST Method
The POST method creates a new resource on the backend (server). The request body carries the data we want to the server. It is neither a safe nor idempotent method. We don’t expect to get the same result every time we send a POST request. For example, two identical POST requests will create two new equivalent resources with the same data and different resource ids.

When sending a POST request to a server, we expect the following to happen:
Ideally, if the POST request has created a new resource on the other side, the response should come with 201 Status Code which means Created.
*Sometimes, performing a POST request doesn’t return a resource at the given URL; in this case, the method will return 204 status code which means No content.
**How to test a POST endpoint*
Since the POST method creates data, we must be cautious about changing data; testing all the POST methods in APIs is highly recommended. Moreover, make sure to delete the created resource once your testing is finished.

Here are some suggestions that we can do for testing APIs with POST methods:

Create a resource with the POST method, and it should return the 201 Status Code.
Perform the GET method to check if it created the resource was successfully created. You should get the 200 status code, and the response should contain the created resource.
Perform the POST method with incorrect or wrong formatted data to check if the operation fails.
3.PUT Method
With the PUT request method, we can update an existing resource by sending the updated data as the content of the request body to the server. The PUT method updates a resource by replacing its entire content completely. If it applies to a collection of resources, it replaces the whole collection, so be careful using it. The server will return the 200 or 204 status codes after the existing resource is updated successfully.
How to test an API with a PUT method?
The PUT method is idempotent, and it modifies the entire resources, so to test that behavior, we make sure to do the following operations:

Send a PUT request to the server many times, and it should always return the same result.
When the server completes the PUT request and updates the resource, the response should come with 200 or 204 status codes.
After the server completes the PUT request, make a GET request to check if the data is updated correctly on the resource.
If the input is invalid or has the wrong format, the resource must not be updated.
4.PATCH Method
PATCH is another HTTP method that is not commonly used. Similar to PUT, PATCH updates a resource, but it updates data partially and not entirely. For example, to make it more precise, the request [PUT] customers/{customerid} would update the fields in the Customers entity on the resource entirely. However, the PATCH method does update the provided fields of the customer entity. In general, this modification should be in a standard format like JSON or XML.
How to test an API with a PATCH method?
To test an API with the PATCH method, follow the steps discussed in this article for the testing API with the PUT and the POST methods. Consider the following results:

Send a PATCH request to the server; the server will return the 2xx HTTP status code, which means: the request is successfully received, understood, and accepted.
Perform the GET request and verify that the content is updated correctly.
If the request payload is incorrect or ill-formatted, the operation must fail.
5.DELETE Method
As the name suggests, the DELETE method deletes a resource. The DELETE method is idempotent; regardless of the number of calls, it returns the same result.

Most APIs always return the 200 status code even if we try to delete a deleted resource but in some APIs, If the target data no longer exists, the method call would return a 404 status code.
How to test a DELETE endpoint?
When it comes to deleting something on the server, we should be cautious. We are deleting data, and it is critical. First, make sure that deleting data is acceptable, then perform the following actions.

Call the POST method to create a new resource. Never test DELETE with actual Data. For example, first, create a new customer and then try to delete the customer you just created.
Make the DELETE request for a specific resource. For example, the request [DELETE] /customers/ {customer-id} deletes a customer with thee specified customer Id.
Call the GET method for the deleted customer, which should return 404, as the resource no longer exists.
Testfully’s Multi-step tests allow you to create resources on the fly and use them for testing DELETE endpoints.
6.HEAD Method
The HEAD method is similar to the GET method. But it doesn’t have any response body, so if it mistakenly returns the response body, it must be ignored. For example, the [GET] /customers endpoint returns a list of customers in its response body. Also, the [HEAD] /customers do the same, but it doesn’t return a list of customers. Before requesting the GET endpoint, we can make a HEAD request to determine the size (Content-length) of the file or data that we are downloading. Therefore, the HEAD method is safe and idempotent.
How to test a HEAD endpoint
One of the advantages of the HEAD method is that we can test the server if it is available and accessible as long as the API supports it, and it is much faster than the GET method because it has no response body. The status code we expect to get from the API is 200. Before every other HTTP method, we can first test API with the HEAD method.
7.OPTIONS Method
We use This method to get information about the possible communication options (Permitted HTTP methods) for the given URL in the server or an asterisk to refer to the entire server. This method is safe and idempotent.

Various browsers widely use the OPTIONS method to check whether the CORS (Cross-Origin resource sharing) operation is restricted on the targeted API or not.
How to test an OPTIONS endpoint
Depending on whether the server supports the OPTIONS method, we can test the server for the times of FATAL failure with the OPTIONS method. To try it, consider the following.

Make an OPTIONS request and check the header and the status code that returns.
Test the case of failure with a resource that doesn’t support the OPTIONS method.
8.TRACE Method
The TRACE method is for diagnosis purposes. It creates a loop-back test with the same request body that the client sent to the server before, and the successful response code is 200 OK. The TRACE method is safe and idempotent.

The TRACE method could be dangerous because it could reveal credentials. A hacker could steal credentials, including internal authentication headers, using a client-side attack.
How to test an API with a TRACE method?
Make a standard HTTP request like a GET request to /api/status
Replace GET with the TRACE and send it again.
Check what the server returns. If the response has the same information as the original request, the TRACE ability is enabled in the server and works correctly.
9.CONNECT Method
The CONNECT method is for making end-to-end connections between a client and a server. It makes a two-way connection like a tunnel between them. For example, we can use this method to safely transfer a large file between the client and the server.
Comparison of HTTP methods
Method Summary CRUD Accepts Request Body Idempotnent Safe
GET To fetch a single resource or group of resources Read No Yes Yes
PUT To update an entire resource in one go Update Yes Yes No
POST To create a new resource Create Yes No No
PATCH To partially update a resource Update Yes No No
DELETE To delete a resource Delete No Yes No
OPTIONS To get information on permitted operations Read No Yes Yes
HEAD To get metadata of the endpoint Read No Yes Yes
TRACE For diagnosing purposes Read No Yes Yes
CONNECT To make the two-way connection between the client and the resource. - No

Inheritance in JavaScript

Sosanya Esther — Sat, 25 Jan 2025 11:38:53 +0000

In programming, inheritance refers to passing down characteristics from a parent to a child so that a new piece of code can reuse and build upon the features of an existing one. JavaScript implements inheritance by using objects.
Inheritance allows you to define a class and then take all the functionality and features of the class and give them to another. The one who gives the features is called the parent class or superclass and the one who inherits the feature is called a child class or subclass. By using inheritance, a class can inherit all the required methods and can also have its unique features.Each object has an internal link to another object called its prototype.
Types of Inheritance in JavaScript
1.Prototypal Inheritance: Prototypal inheritance is a type of inheritance that adds new properties and methods to an existing object.
function Animal(name) {
this.name = name;
}

Animal.prototype.sound = function() {
console.log("Some generic sound");
};

function Dog(name, breed) {
Animal.call(this, name);
this.breed = breed;
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

Dog.prototype.sound = function() {
console.log("Woof! Woof!");
};

class car extends automobile {
engine() {
console.log(this.name,
"has ", this.cc, "cc engine");
}
}

let carz = new car('Rex', "1149");
carz.engine();
3.Functional Inheritance: From the name of the inheritance, you understand that this type of inheritance in JavaScript makes use of functions. Functional Inheritance uses an augmenting function to the instance of the object in order to inherit the features of that object.
function Animal(name) {
const obj = {};
obj.name = name;

obj.sound = function() {
    console.log(&quot;Some generic sound&quot;);
};

return obj;

}

function Dog(name, breed) {
const obj = Animal(name);
obj.breed = breed;

obj.sound = function() {
    console.log(&quot;Woof! Woof!&quot;);
};

return obj;

}

const myDog = Dog("Buddy", "Labrador");
myDog.sound(); // Outputs: Woof! Woof!

Scopes in JavaScript

Sosanya Esther — Fri, 24 Jan 2025 11:28:47 +0000

What is Scope?
Scope in JavaScript refers to the context or environment in which variables are declared and can be accessed.A solid scope is indispensable because it can affect how your code behaves and interacts with other parts of your application.
JavaScript has two types of scope:
1.Local scope
2.Global scope
These scopes control the accessibility of variables in different parts of your code and play a pivotal role in maintaining code organization and preventing variable conflicts.

Local scope: Any variable that you declare inside a function is said to have Local Scope. Local variables have Function scope: They can only be accessed from within the
function.Local variables are created when a function starts, and deleted when the function
is completed. If you try to access any variable defined inside a function from outside or another function, it throws an error.Since you cannot access a local variable from outside the function, you can have a variable of the same name in another function as well.
Global scope: Any variable declared outside of a function is said to have Global Scope.
In simple terms, a variable that can be accessed anywhere in the program is known as a variable with global scope.
A global variable has global scope: All scripts and functions on a web page can
access it.
Global variables are created when you assign a value to them. Global variables are deleted when you close the page.
Globally scoped variables can be defined using any of the three keywords: let, const, and var.

Constructors in JavaScript

Sosanya Esther — Sat, 18 Jan 2025 13:06:16 +0000

The Javascript Set Constructor is used to create Set objects. It will create a set of unique values of any type, whether primitive values or object preferences.
A constructor is useful when you want to create multiple similar objects with the same properties and methods. It’s a convention to capitalize the name of constructors to distinguish them from regular functions.

The last line of the code creates an instance of Book and assigns it to a variable. Although the Book constructor doesn’t do anything, myBook is still an instance of it. As you can see, there is no difference between this function and regular functions except that it’s called with the new keyword and the function name is capitalized.

A constructor is a function that executes the initialization of an object when the object is created. Arguments are passed to the constructor function when you use the new keyword.
There are two types of constructors, one defined as a function, and one defined with the constructor method in a class.

The Object Constructor Function:
To use a constructor function to create objects, simply define a JavaScript function with any number of arguments. Inside the function, the keyword this is used as a placeholder for the object being created. If the constructor function is used by itself, without the new statement, this will have no value.
It’s preferred to capitalize a constructor function.

The Class constructor Method:
When defining a class in JavaScript, there is a special constructor method defined within it. Like the object constructor function, the constructor method can be defined with any number of arguments, and the this keyword can be used as a placeholder for the object being created.