# JavaScript : Numbers and dates JavaScript, often abbreviated as JS, is a powerful programming language that is widely used in web development. It provides a number of data types, including numbers and dates, which are essential for various calculations and time-related operations in JavaScript applications.

Numbers in JavaScript are represented by the number data type. They can be either whole numbers, known as integers, or numbers with decimal points, known as floating-point numbers. JavaScript uses 64-bit floating-point precision to handle all numbers, regardless of their size or decimal places. This allows for accurate calculations and operations with numbers in JavaScript.

Dates in JavaScript are represented by the date data type. They allow developers to work with dates and times, such as displaying current date and time, calculating time differences, and formatting dates according to specific patterns. JavaScript provides a built-in Date object that can be used to create, manipulate, and display dates in various formats.

“JavaScript numbers and dates are integral to many web applications, from simple calculators to complex event scheduling systems. Having a solid understanding of how they work and how to use them effectively is essential for any JavaScript developer.”

## What are JavaScript Numbers?

In JavaScript, numbers are a primitive data type used to represent numerical values. They can be positive or negative, and can include whole numbers, decimal numbers, and even scientific notation.

JavaScript numbers are stored as 64-bit floating point numbers, which allows for a wide range of values to be represented accurately. However, there are some limitations to the precision of JavaScript numbers due to the nature of floating point arithmetic.

### Number Types in JavaScript

JavaScript supports the following types of numbers:

• Integers: These are whole numbers without any fractional or decimal part. Examples include 0, 10, -25, etc.
• Floats: These are numbers with decimal points. Examples include 3.14, -2.5, 0.75, etc.
• NaN: Stands for “Not a Number” and represents an invalid or unrepresentable value.
• Infinity and -Infinity: Represent positive and negative infinity, respectively. These values are returned when a number exceeds the maximum value JavaScript can represent.

### Working with Numbers in JavaScript

JavaScript provides built-in mathematical operations and functions that allow you to perform calculations and manipulate numbers.

Here are some basic operations you can perform with numbers in JavaScript:

• Addition: `5 + 10` returns `15`
• Subtraction: `8 - 3` returns `5`
• Multiplication: `3 * 4` returns `12`
• Division: `15 / 3` returns `5`
• Modulo: `16 % 5` returns `1`

In addition to these basic operations, JavaScript also provides functions for more complex mathematical operations, such as calculating square roots, generating random numbers, and rounding numbers.

### Number Conversions

JavaScript provides several built-in functions for converting between different number formats:

• `parseFloat()` – Converts a string to a floating point number
• `parseInt()` – Converts a string to an integer number
• `Number()` – Converts a value to a number

It’s important to note that when converting a string to a number, JavaScript will try to parse the string as much as possible. If the string contains non-numeric characters or is empty, the conversion will result in `NaN`.

Overall, JavaScript numbers are a fundamental part of the language and are used extensively in various applications, ranging from simple calculations to complex mathematical operations.

## Basic Operations with JavaScript Numbers

### Arithmetic Operations

JavaScript provides built-in operators for performing arithmetic operations on numbers. These operators include:

• Subtraction (-): The subtraction operator is used to subtract one number from another.
• Multiplication (*): The multiplication operator is used to multiply two numbers.
• Division (/): The division operator is used to divide one number by another.
• Modulus (%): The modulus operator is used to find the remainder of the division of one number by another.
• Exponentiation (**): The exponentiation operator is used to raise a number to a power.

### Example:

Let’s take a look at some examples of basic arithmetic operations:

Operation Expression Result
Addition `2 + 3` 5
Subtraction `5 - 2` 3
Multiplication `2 * 3` 6
Division `6 / 3` 2
Modulus `7 % 3` 1
Exponentiation `2 ** 3` 8

### Increment and Decrement Operations

JavaScript also provides increment and decrement operators to easily increase or decrease the value of a number by 1. These operators include:

• Increment (++): The increment operator is used to increase the value of a number by 1.
• Decrement (–): The decrement operator is used to decrease the value of a number by 1.

### Example:

Let’s see some examples of increment and decrement operations:

Operation Initial Value Expression Result
Increment 5 `++5` 6
Decrement 8 `--8` 7

### Conclusion

In this article, we’ve explored the basic operations that can be performed with numbers in JavaScript. These operations include arithmetic operations like addition, subtraction, multiplication, division, modulus, and exponentiation, as well as increment and decrement operations. Understanding these basic operations is essential for working with numbers in JavaScript.

## Math Object in JavaScript

The Math object in JavaScript provides a set of built-in mathematical functions and constants.

### Math Constants

• Math.PI: Returns the value of Pi, approximately 3.14159.
• Math.E: Returns the value of Euler’s constant, approximately 2.71828.

### Math Methods

• Math.abs(x): Returns the absolute value of a number.
• Math.ceil(x): Returns the smallest integer greater than or equal to a number.
• Math.floor(x): Returns the largest integer less than or equal to a number.
• Math.round(x): Returns the value of a number rounded to the nearest integer.
• Math.max(x, y, …): Returns the largest number from the provided arguments.
• Math.min(x, y, …): Returns the smallest number from the provided arguments.
• Math.pow(x, y): Returns the value of x raised to the power of y.
• Math.sqrt(x): Returns the square root of a number.
• Math.random(): Returns a random number between 0 (inclusive) and 1 (exclusive).
• Math.floor(Math.random() * n): Returns a random integer between 0 (inclusive) and n (exclusive).

### Math Object Example:

```
```
````const radius = 2.5;````
const area = Math.PI * Math.pow(radius, 2);
console.log(area);
```
```

This example calculates the area of a circle with a radius of 2.5 using the formula A = πr². The Math.PI constant is used to represent the value of Pi, and the Math.pow method is used to calculate the square of the radius. The result is then logged to the console.

## JavaScript Numbers and Strings

In JavaScript, numbers and strings are two important data types that you will frequently work with. In this section, we will explore how to work with numbers and strings in JavaScript.

### Numbers

JavaScript has a built-in numeric data type for representing numbers. You can perform various arithmetic operations on numbers such as addition, subtraction, multiplication, and division.

Here are some examples of how to work with numbers in JavaScript:

• Addition: To add two numbers together, you can use the `+` operator. For example: `let sum = 5 + 3;`
• Subtraction: To subtract one number from another, you can use the `-` operator. For example: `let difference = 8 - 4;`
• Multiplication: To multiply two numbers, you can use the `*` operator. For example: `let product = 2 * 6;`
• Division: To divide one number by another, you can use the `/` operator. For example: `let quotient = 10 / 2;`
• Modulus: The modulus operator `%` returns the remainder of a division. For example: `let remainder = 15 % 4;`

In addition to these basic arithmetic operations, JavaScript provides various built-in methods and properties for working with numbers. For example, you can use the `Math` object to perform more complex mathematical calculations.

### Strings

In JavaScript, strings are used to represent and manipulate text. You can create strings by enclosing text in single quotes (`'`) or double quotes (`"`).

Here are some examples of how to work with strings in JavaScript:

• Concatenation: To join two strings together, you can use the `+` operator. For example: `let greeting = 'Hello' + 'World';`
• Length: To get the length of a string, you can use the `length` property. For example: `let message = 'Hello'; let length = message.length;`
• Accessing Characters: You can access individual characters in a string using square brackets and the index of the character. For example: `let name = 'John'; let firstLetter = name;`
• String Methods: JavaScript provides various built-in methods for working with strings. Some commonly used string methods include `toLowerCase()`, `toUpperCase()`, `substring()`, and `indexOf()`.

By understanding how to work with numbers and strings in JavaScript, you will be able to perform a wide range of calculations and manipulate text effectively in your applications.

## NaN and Infinity in JavaScript Numbers

In JavaScript, numbers can take on special values known as NaN (Not a Number) and Infinity. These special values can arise as a result of mathematical operations or when working with invalid numbers.

### NaN (Not a Number)

NaN is a special value in JavaScript that represents an undefined or unrepresentable value resulting from an invalid mathematical operation. It is considered as a numeric data type, but it is not equal to any other value, including itself.

Here are some examples of operations that can result in NaN:

• Dividing zero by zero: `console.log(0 / 0); // NaN`
• Taking the square root of a negative number: `console.log(Math.sqrt(-1)); // NaN`
• Performing arithmetic with non-numeric strings: `console.log(parseInt('hello')); // NaN`
• Trying to convert a non-numeric value to a number: `console.log(Number('undefined')); // NaN`

### Infinity

Infinity is another special value in JavaScript that represents positive or negative infinity. It is the result of dividing a non-zero number by zero or when the result of an operation exceeds the upper limit of representable numbers.

Here are some examples that can result in Infinity:

• Dividing a positive number by zero: `console.log(5 / 0); // Infinity`
• Multiplying a number by Infinity: `console.log(10 * Infinity); // Infinity`
• Taking the exponentiation of a large number: `console.log(Math.pow(2, 1000)); // Infinity`

### Handling NaN and Infinity When dealing with NaN and Infinity, it is important to handle them appropriately to prevent unexpected behavior in your code.

You can use the `isNaN()` function to determine if a value is NaN:

``````console.log(isNaN(NaN)); // true
console.log(isNaN(123)); // false
``````

To check for Infinity, you can use the `isFinite()` function:

``````console.log(isFinite(Infinity)); // false
console.log(isFinite(123)); // true
``````

If you want to remove or replace NaN or Infinity values in your calculations, you can use the `isNaN()` and `isFinite()` functions in combination with conditional statements.

Overall, understanding NaN and Infinity in JavaScript numbers is essential for handling unexpected results and ensuring the correctness of your mathematical operations.

## Rounding Numbers in JavaScript

### Introduction

When working with numbers in JavaScript, it’s often necessary to round them to a specific decimal place or to the nearest whole number. This can be useful in a variety of scenarios, such as when performing calculations, displaying data, or formatting output. Fortunately, JavaScript provides several methods and techniques for rounding numbers.

### Rounding to the Nearest Whole Number

One common task is to round a number to the nearest whole number. This can be achieved using the `Math.round()` method, which rounds a number to the nearest integer. Here’s an example:

```
```
````let num = 5.7;````
let roundedNum = Math.round(num);
console.log(roundedNum); // Output: 6
```
```

In this example, the `num` variable is rounded to the nearest whole number using the `Math.round()` method, and the result is stored in the `roundedNum` variable.

### Rounding to a Specific Decimal Place

Sometimes, it’s necessary to round a number to a specific decimal place, such as rounding to two decimal places for currency formatting. JavaScript provides the `toFixed()` method, which rounds a number to a specific number of decimal places. Here’s an example:

```
```
````let num = 3.14159;````
let roundedNum = num.toFixed(2);
console.log(roundedNum); // Output: "3.14"
```
```

In this example, the `num` variable is rounded to two decimal places using the `toFixed()` method, and the result is stored in the `roundedNum` variable. Note that the `toFixed()` method returns a string representation of the rounded number.

### Rounding Down and Up

In addition to rounding to the nearest whole number or a specific decimal place, JavaScript provides methods for rounding down and rounding up a number. The `Math.floor()` method rounds a number down to the nearest integer, while the `Math.ceil()` method rounds a number up to the nearest integer.

Here’s an example of rounding down:

```
```
````let num = 9.8;````
let roundedNum = Math.floor(num);
console.log(roundedNum); // Output: 9
```
```

And here’s an example of rounding up:

```
```
````let num = 4.2;````
let roundedNum = Math.ceil(num);
console.log(roundedNum); // Output: 5
```
```

In both examples, the original number is rounded down or up using the respective method, and the result is stored in the `roundedNum` variable.

### Conclusion

In JavaScript, rounding numbers can be accomplished using the `Math.round()`, `toFixed()`, `Math.floor()`, and `Math.ceil()` methods. These methods provide flexibility for rounding numbers to the nearest whole number or a specific decimal place, as well as rounding down or rounding up.

By understanding and utilizing these rounding techniques, JavaScript developers can accurately manipulate and format numbers to meet the requirements of their applications.

## JavaScript Dates

In JavaScript, dates are represented by the `Date` object. This object allows us to manipulate, format, and perform various operations with dates.

### Creating a Date

To create a new date, we can use the `new Date()` constructor. This creates a date object representing the current date and time:

``````const currentDate = new Date();
console.log(currentDate);
``````

We can also create a date object for a specific date and time by passing the desired values as arguments to the constructor:

``````const specificDate = new Date(2022, 11, 25, 10, 30, 0);
console.log(specificDate);
``````

### Date Methods

The `Date` object provides several built-in methods to work with dates:

• `getDate()`: Returns the day of the month (from 1 to 31)
• `getMonth()`: Returns the month (from 0 to 11)
• `getFullYear()`: Returns the year (four digits)
• `getHours()`: Returns the hour (from 0 to 23)
• `getMinutes()`: Returns the minutes (from 0 to 59)
• `getSeconds()`: Returns the seconds (from 0 to 59)
• `getMilliseconds()`: Returns the milliseconds (from 0 to 999)
• `getTime()`: Returns the number of milliseconds since January 1, 1970

These methods can be used to extract specific information from a date object.

### Date Formatting

To format a date, JavaScript’s `Date` object provides several methods to retrieve the different parts of a date, such as the day, month, year, and time. We can then use string concatenation or template literals to format the date as per our requirements.

``````const date = new Date();
const day = date.getDate();
const month = date.getMonth() + 1;
const year = date.getFullYear();
const formattedDate = `\${month}/\${day}/\${year}`;
console.log(formattedDate);
``````

This will output the date in the format MM/DD/YYYY.

### Date Comparison

We can compare two dates using the comparison operators (`<`, `<=`, `>`, `>=`). JavaScript’s `Date` object allows us to directly compare two date objects:

``````const firstDate = new Date(2022, 3, 15);
const secondDate = new Date(2022, 3, 20);
if (firstDate < secondDate) {
console.log("The first date is earlier");
} else if (firstDate > secondDate) {
console.log("The second date is earlier");
} else {
console.log("Both dates are equal");
}
``````

This will output “The first date is earlier” as the first date is before the second date.

### Date Arithmetic

We can perform arithmetic operations on dates using the `Date` object. For example, we can add/subtract days, months, or years to/from a date:

``````const date = new Date();
date.setDate(date.getDate() + 7);
console.log(date);
``````

This will add 7 days to the current date.

### Conclusion

JavaScript’s `Date` object provides powerful features to work with dates. With its methods and properties, we can create, manipulate, format, compare, and perform arithmetic operations on dates with ease.

## Creating and Working with Dates in JavaScript JavaScript provides a built-in Date object that allows you to work with dates and times. This object provides various methods for creating, manipulating, and formatting dates. In this article, we will explore the different ways to create and work with dates in JavaScript.

### Creating a Date Object

To create a new Date object, you can use the `new Date()` constructor. This constructor accepts various arguments, such as year, month, day, hour, minute, second, and millisecond. If no arguments are provided, the Date object will represent the current date and time.

Example:

``````let currentDate = new Date();
````console.log(currentDate);````

This will create a new Date object representing the current date and time, and then log it to the console.

### Working with Dates

Once you have created a Date object, you can perform various operations on it. Some commonly used methods for working with dates include:

• `getFullYear()`: Returns the four-digit year.
• `getMonth()`: Returns the month (0-11).
• `getDate()`: Returns the day of the month (1-31).
• `getDay()`: Returns the day of the week (0-6, where Sunday is 0).
• `getHours()`: Returns the hour (0-23).
• `getMinutes()`: Returns the minute (0-59).
• `getSeconds()`: Returns the second (0-59).
• `getMilliseconds()`: Returns the millisecond (0-999).

Example:

``````let currentDate = new Date();
let year = currentDate.getFullYear();
let month = currentDate.getMonth();
let day = currentDate.getDate();
let hour = currentDate.getHours();
let minute = currentDate.getMinutes();
let second = currentDate.getSeconds();
let millisecond = currentDate.getMilliseconds();
````console.log(year, month, day, hour, minute, second, millisecond);````

This will create a new Date object representing the current date and time, and then extract various date and time components from it and log them to the console.

### Formatting Dates

JavaScript provides various methods for formatting dates into strings. Some commonly used methods for formatting dates include:

• `toDateString()`: Returns the date portion of the Date object as a string.
• `toLocaleDateString()`: Returns a string representing the date portion of the Date object using locale-specific formatting.
• `toTimeString()`: Returns the time portion of the Date object as a string.
• `toLocaleTimeString()`: Returns a string representing the time portion of the Date object using locale-specific formatting.
• `toString()`: Returns a string representing the entire Date object.
• `toLocaleString()`: Returns a string representing the entire Date object using locale-specific formatting.

Example:

``````let currentDate = new Date();
let dateString = currentDate.toDateString();
let timeString = currentDate.toTimeString();
````console.log(dateString, timeString);````

This will create a new Date object representing the current date and time, and then format the date portion and time portion into separate strings and log them to the console.

### Conclusion

The Date object in JavaScript provides a powerful way to work with dates and times. With its various methods for creating, manipulating, and formatting dates, you can effectively handle a wide range of date-related tasks in your JavaScript applications.

## Formatting Dates in JavaScript

### Date Object

JavaScript provides a built-in Date object that represents a single moment in time. This object can be used to perform operations on dates, such as formatting them in different ways.

### Date Formatting Methods

The Date object in JavaScript provides several methods for formatting dates. Some of the commonly used methods include:

• getFullYear(): Returns the year of the specified date as a four-digit number.
• getMonth(): Returns the month of the specified date as a number (0-11).
• getDate(): Returns the day of the month of the specified date as a number (1-31).
• getHours(): Returns the hour of the specified date as a number (0-23).
• getMinutes(): Returns the minutes of the specified date as a number (0-59).
• getSeconds(): Returns the seconds of the specified date as a number (0-59).

### Formatting Examples

Here are some examples of how to format dates in JavaScript:

• Format: “yyyy-mm-dd”

JavaScript code:

`const date = new Date();`

``` const year = date.getFullYear(); const month = date.getMonth() + 1; const day = date.getDate(); const formattedDate = year + "-" + month + "-" + day; ```

`console.log(formattedDate);`

Output: “2023-01-05”

• Format: “dd/mm/yyyy”

JavaScript code:

`const date = new Date();`

``` const year = date.getFullYear(); const month = date.getMonth() + 1; const day = date.getDate(); const formattedDate = day + "/" + month + "/" + year; ```

`console.log(formattedDate);`

Output: “05/01/2023”

• Format: “hh:mm:ss”

JavaScript code:

`const date = new Date();`

``` const hours = date.getHours(); const minutes = date.getMinutes(); const seconds = date.getSeconds(); const formattedTime = hours + ":" + minutes + ":" + seconds; ```

`console.log(formattedTime);`

Output: “12:30:45”

### Conclusion

Formatting dates in JavaScript can be done using the various methods provided by the Date object. By extracting the different components of a date, such as year, month, day, hour, minute, and second, you can format the date in any desired format.

## JavaScript Date Methods

The JavaScript `Date` object provides various methods to work with dates and times. These methods allow you to perform different operations on dates such as getting and setting values, formatting dates, and calculating time intervals.

### Creating a Date Object

To create a new `Date` object, you can use the `new Date()` constructor. If you do not provide any arguments, it will create a new `Date` object representing the current date and time.

``const now = new Date();``

### Getting Date and Time Components

The `Date` object provides several methods to extract individual components of a date and time such as the year, month, day, hour, minute, and second.

Method Description
`getFullYear()` Returns the year (4 digits).
`getMonth()` Returns the month (0-11).
`getDate()` Returns the day of the month (1-31).
`getDay()` Returns the day of the week (0-6).
`getHours()` Returns the hour (0-23).
`getMinutes()` Returns the minutes (0-59).
`getSeconds()` Returns the seconds (0-59).

### Formatting Dates

The `Date` object also provides methods to format dates into strings. The most commonly used methods for formatting dates are `toLocaleString()`, `toUTCString()`, and `toISOString()`.

``````const date = new Date();
console.log(date.toLocaleString()); // Returns the date and time in local time zone
console.log(date.toUTCString()); // Returns the date and time in UTC
````console.log(date.toISOString()); // Returns the date and time in ISO 8601 format````

### Calculating Time Intervals

You can perform calculations on dates using methods such as `getTime()`, `setTime()`, `getTimezoneOffset()`, `setFullYear()`, `setMonth()`, `setDate()`, and `setHours()`.

``````const start = new Date();
// Perform some operations...
const end = new Date();
const elapsedTime = end.getTime() - start.getTime();
````console.log(elapsedTime); // Returns the time interval in milliseconds````

These are just a few of the many methods available in the `Date` object. Understanding and utilizing the various date methods in JavaScript will enable you to work effectively with dates and times in your JavaScript code.

## FAQ:

#### What is the purpose of the Number object in JavaScript?

The Number object in JavaScript is used to perform mathematical operations on numbers. It provides various methods and properties to work with numbers.

#### What is the difference between parseInt() and parseFloat() functions?

The parseInt() function is used to parse a string and return an integer. It stops parsing when it encounters a non-digit character. The parseFloat() function, on the other hand, parses a string and returns a floating-point number. It can handle decimal values and stops parsing when it encounters a non-digit character other than a decimal point.

#### How can I format a date and time in JavaScript?

In JavaScript, you can format a date and time using the various methods available on the Date object. For example, you can use the toLocaleDateString() method to get the formatted date string in the user’s local timezone. Similarly, you can use the toLocaleTimeString() method to get the formatted time string in the user’s local timezone. You can also use the toLocaleString() method to get the formatted date and time string in the user’s local timezone. There are also other methods available to get the individual components of the date and time, such as getFullYear(), getMonth(), getDate(), getHours(), getMinutes(), etc.