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 timerelated 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 floatingpoint numbers. JavaScript uses 64bit floatingpoint 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 builtin 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.”
Table of Contents
 1 What are JavaScript Numbers?
 2 Basic Operations with JavaScript Numbers
 3 Math Object in JavaScript
 4 JavaScript Numbers and Strings
 5 NaN and Infinity in JavaScript Numbers
 6 Rounding Numbers in JavaScript
 7 JavaScript Dates
 8 Creating and Working with Dates in JavaScript
 9 Formatting Dates in JavaScript
 10 JavaScript Date Methods
 11 FAQ:
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 64bit 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 builtin 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
returns15
 Subtraction:
8  3
returns5
 Multiplication:
3 * 4
returns12
 Division:
15 / 3
returns5
 Modulo:
16 % 5
returns1
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 builtin functions for converting between different number formats:
parseFloat()
– Converts a string to a floating point numberparseInt()
– Converts a string to an integer numberNumber()
– 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 nonnumeric 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 builtin operators for performing arithmetic operations on numbers. These operators include:
 Addition (+): The addition operator is used to add two numbers.
 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 builtin 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 builtin 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 builtin 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[0];
 String Methods: JavaScript provides various builtin methods for working with strings. Some commonly used string methods include
toLowerCase()
,toUpperCase()
,substring()
, andindexOf()
.
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 nonnumeric strings:
console.log(parseInt('hello')); // NaN
 Trying to convert a nonnumeric 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 nonzero 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 builtin 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 builtin 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 fourdigit year.getMonth()
: Returns the month (011).getDate()
: Returns the day of the month (131).getDay()
: Returns the day of the week (06, where Sunday is 0).getHours()
: Returns the hour (023).getMinutes()
: Returns the minute (059).getSeconds()
: Returns the second (059).getMilliseconds()
: Returns the millisecond (0999).
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 localespecific 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 localespecific formatting.toString()
: Returns a string representing the entire Date object.toLocaleString()
: Returns a string representing the entire Date object using localespecific 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 daterelated tasks in your JavaScript applications.
Formatting Dates in JavaScript
Date Object
JavaScript provides a builtin 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 fourdigit number.
 getMonth(): Returns the month of the specified date as a number (011).
 getDate(): Returns the day of the month of the specified date as a number (131).
 getHours(): Returns the hour of the specified date as a number (023).
 getMinutes(): Returns the minutes of the specified date as a number (059).
 getSeconds(): Returns the seconds of the specified date as a number (059).
Formatting Examples
Here are some examples of how to format dates in JavaScript:

Format: “yyyymmdd”
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: “20230105”

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 (011). 
getDate() 
Returns the day of the month (131). 
getDay() 
Returns the day of the week (06). 
getHours() 
Returns the hour (023). 
getMinutes() 
Returns the minutes (059). 
getSeconds() 
Returns the seconds (059). 
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 nondigit character. The parseFloat() function, on the other hand, parses a string and returns a floatingpoint number. It can handle decimal values and stops parsing when it encounters a nondigit 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.