# How to Square a Number in JavaScript

Moataz Farid Feb 02, 2024

In this article, we will explore multiple ways to square a number in JavaScript.

Squaring a number is a fundamental mathematical operation, and JavaScript offers several techniques to achieve this, from built-in functions to modern approaches like ES6 arrow functions and external libraries.

By the end of this article, you will have a clear understanding of how to square a number using different methods and the advantages of each approach.

## Use the `Math.pow()` Method to Square a Number in JavaScript

When you need to square a number in JavaScript, one of the methods at your disposal is the `Math.pow()` method. The `Math.pow()` method is a built-in JavaScript function that allows you to raise a number to a specified exponent.

Its primary purpose is to calculate the power of a number. The method takes two arguments: the base number and the exponent.

When you use it to square a number, you set the exponent to `2`. Here’s the syntax of the `Math.pow()` method:

``````Math.pow(base, exponent);
``````
• `base`: This is the number you want to square, and it is the base of the power operation.
• `exponent`: This is the exponent to which the base is raised. In the case of squaring, it should be set to `2`.

Squaring a number using the `Math.pow()` method is straightforward. You provide the number you want to square as the base and set the exponent to `2`.

Here’s an example:

``````const number = 5;
const squared = Math.pow(number, 2);

console.log(squared); // Output: 25
``````

Output:

``````25
``````

In this example, we declare a constant variable named `number` and assign it the value `5`. Then, we square the number `5` by using `Math.pow(number, 2)`.

The result, stored in the `squared` variable, is `25`, which is the square of `5`.

## Use the `Exponentiation` Method to Square a Number in JavaScript ECMAScript 6

Another way to square a number in JavaScript ECMAScript 6 is to use the exponentiation operator (`**`). Introduced in ECMAScript 6 (ES6), it is a concise and easy-to-use feature that allows you to calculate the power of a number.

In the context of squaring a number, you can use the operator to raise a number to the power of `2`.

The syntax of the exponentiation operator is simple:

``````base ** exponent
``````
• `base`: This is the number you want to square. It’s the base of the power operation.
• `exponent`: Here, you set the exponent to `2` to square the number.

Squaring a number with the exponentiation operator is straightforward and intuitive. You simply provide the number you want to square as the base and set the exponent to `2`.

Here’s an example:

``````const number = 5;
const squared = number ** 2;

console.log(squared);
``````

Output:

``````25
``````

In this example, we declare a constant variable named `number` and assign it the value `5`. Then, we square the number `5` by using the exponentiation operator, `number ** 2`.

The result, stored in the `squared` variable, is `25`, which is the square of `5`.

## Use the `bigInt()` Library to Square a Number in JavaScript

In addition to the built-in capabilities of JavaScript, you can extend its functionality by incorporating external libraries. One such library that can be helpful in performing operations like squaring a number is `BigInteger.js`.

Before you can use the `BigInteger.js` library, you need to import it into your JavaScript project. Fortunately, this can be easily done through a Content Delivery Network (CDN) link.

Add the following script tag to your HTML file, and it will fetch the library for you:

``````<script src="https://cdnjs.cloudflare.com/ajax/libs/big-integer/1.6.40/BigInteger.min.js"></script>
``````

By including this script, you ensure that the library is available for your JavaScript code to utilize.

With the library successfully imported, you can now proceed to square a number. To do this, you create a function that takes the number you want to square as its parameter, and within the function, you use the `bigInt()` constructor to create a `BigInteger` instance and then apply the `.square()` method to it.

Here’s the code:

``````function squareMyNumber(number) {
return bigInt(number).square();
}

let squared = squareMyNumber(5);
console.log('Square of 5 using the `bigInt` library: ' + squared.toString());
``````

In this code, we’ve defined the `squareMyNumber` function, which takes the number to be squared (`number`) as its argument. It then uses `bigInt(number).square()` to square the number, and the result is returned.

We’ve stored the squared value in the `squared` variable and logged it to the console.

After running the code, you can see the squared result in the console:

``````Square of 5 using the `bigInt` library: 25
``````

The output confirms that the `bigInt()` library successfully squared the number `5`, yielding the expected result of `25`.

## Use the Multiplication Operator (`*`) to Square a Number in JavaScript

The multiplication operator (`*`), as the name suggests, is used in JavaScript to multiply two numbers. When you want to square a number, you can achieve this by multiplying the number by itself.

This is because squaring a number is essentially raising it to the power of `2`.

Here’s how you can use the multiplication operator to square a number:

``````number * number
``````
• `number`: This is the number you want to square. By multiplying it by itself, you effectively calculate its square.

Squaring a number using the multiplication operator is a simple and intuitive process. You merely need to multiply the number by itself, and the result is the square of that number.

Here’s an example:

``````const number = 5;
const squared = number * number;
console.log(`The square of \${number} is \${squared}`);
``````

Output:

``````The square of 5 is 25
``````

This code begins by declaring a constant variable named `number` and assigns it the value `5`.

The subsequent line calculates the square of the number by using the multiplication operator `*`. It multiplies the `number` variable by itself, effectively squaring it.

The result of this multiplication is assigned to another constant variable called `squared`.

Finally, the code utilizes the `console.log()` function to print a message with the actual values of `number` and `squared`, replacing the respective placeholders.

## Use a Named Function to Square a Number in JavaScript

A named function is a JavaScript function that has a specified name and a well-defined purpose. To square a number using a named function, follow this guide:

Start by creating a JavaScript function with a name that reflects its purpose. In this case, we want to create a function to square a number, so we’ll name it `squareNumber`.

Here’s an example:

``````function squareNumber(number) {
return number * number;
}
``````

This function takes one parameter, `number`, and returns the square of that number.

Once you’ve defined the named function, you can call it with any number you want to square:

``````const number = 5;
const squared = squareNumber(number);
console.log(`The square of \${number} is \${squared}`);
``````

Output:

``````The square of 5 is 25
``````

This code starts by declaring a constant variable named `number` and assigns it the value `5`. This variable represents the number we want to square.

Next, it declares another constant variable named `squared`, which is assigned the result of calling a function named `squareNumber` with the `number` variable as its argument. This suggests that the `squareNumber` function performs the squaring operation, and its result is stored in the `squared` variable.

Finally, the code uses `console.log()` to print a message to the console. This message is constructed using template literals, denoted by backticks, and it contains placeholders for the `number` and `squared` variables.

When executed, this line will produce an output with the actual values of `number` and `squared` replacing the respective placeholders in the message.

## Use an Anonymous Function (ES6 Arrow Function) to Square a Number in JavaScript

ES6 (ECMAScript 2015) introduced arrow functions as a concise and convenient way to write functions in JavaScript. They are also known as “fat arrow” functions and offer a shorter syntax compared to traditional function declarations.

Arrow functions are particularly useful for creating anonymous functions for simple, single-expression tasks.

Here’s the basic syntax of an arrow function for squaring a number:

``````const square = (number) => number * number;
``````

In this example, `(number)` represents the function’s parameter, `=>` is the arrow notation, and `number * number` is the expression that is returned.

Squaring a number using an ES6 arrow function is straightforward. You define a function that takes the number you want to square as a parameter and returns the square of that number.

Here’s how it’s done:

``````const square = (number) => number * number;

const number = 5;
const squared = square(number);
console.log(`The square of \${number} is \${squared}`);
``````

Output:

``````The square of 5 is 25
``````

In this code, we declare an arrow function named `square` that takes a parameter called `number`. The function uses the arrow notation `=>` to indicate that it returns the result of `number * number`, which computes the square of the input number.

After defining the function, we assign the number `5` to the `number` variable. Then, we call the `square` function with this value and store the result in the `squared` variable.

Finally, we use `console.log()` to print a message to the console, displaying both the original number and its square.

## Conclusion

In JavaScript, squaring a number can be accomplished using a variety of methods, each with its unique advantages. You can utilize the `Math.pow()` method for a built-in solution, the exponentiation operator (`**`) introduced in ECMAScript 6 for modern and concise code, the `bigInt()` library for handling large integers, or the multiplication operator (`*`) for a simple and efficient approach.

Additionally, you can create named functions or utilize ES6 arrow functions for clear and reusable code.

The choice of method depends on your specific needs and the context of your JavaScript project. Whether you prioritize simplicity, performance, or modularity, JavaScript provides a range of options to square numbers effectively.