123456789042

Decimal literals can start with a zero (0) followed by another decimal digit, but if all digits after the leading0 are smaller than 8, the number is interpreted as an octal number. This is considered a legacy syntax, and number literals prefixed with0, whether interpreted as octal or decimal, cause a syntax error instrict mode — so, use the0o prefix instead.

0888 // 888 parsed as decimal0777 // parsed as octal, 511 in decimal

Binary number syntax uses a leading zero followed by a lowercase or uppercase Latin letter "B" (0b or0B). If the digits after the0b are not 0 or 1, the followingSyntaxError is thrown: "Missing binary digits after 0b".

0b10000000000000000000000000000000 // 21474836480b01111111100000000000000000000000 // 21390950400B00000000011111111111111111111111 // 8388607

The standard syntax for octal numbers is to prefix them with0o. For example:

0O755 // 4930o644 // 420

There's also a legacy syntax for octal numbers — by prefixing the octal number with a zero:0644 === 420 and"\045" === "%". If the digits after the0 are outside the range 0 through 7, the number will be interpreted as a decimal number.

const n = 0755; // 493const m = 0644; // 420

Strict mode forbids this octal syntax.

Hexadecimal number syntax uses a leading zero followed by a lowercase or uppercase Latin letter "X" (0x or0X). If the digits after 0x are outside the range (0123456789ABCDEF), the followingSyntaxError is thrown: "Identifier starts immediately after numeric literal".

0xFFFFFFFFFFFFF // 45035996273704950xabcdef123456  // 1889009675930460XA             // 10

The built-inNumber object has properties for numerical constants, such as maximum value, not-a-number, and infinity. You cannot change the values of these properties and you use them as follows:

const biggestNum = Number.MAX_VALUE;const smallestNum = Number.MIN_VALUE;const infiniteNum = Number.POSITIVE_INFINITY;const negInfiniteNum = Number.NEGATIVE_INFINITY;const notANum = Number.NaN;

You always refer to a property of the predefinedNumber object as shown above, and not as a property of aNumber object you create yourself.

The following table summarizes theNumber object's properties.

TheNumber prototype provides methods for retrieving information fromNumber objects in various formats. The following table summarizes the methods ofNumber.prototype.

The built-inMath object has properties and methods for mathematical constants and functions. For example, theMath object'sPI property has the value of pi (3.141…), which you would use in an application as

Math.PI;

Similarly, standard mathematical functions are methods ofMath. These include trigonometric, logarithmic, exponential, and other functions. For example, if you want to use the trigonometric function sine, you would write

Math.sin(1.56);

Note that all trigonometric methods ofMath take arguments in radians.

The following table summarizes theMath object's methods.

Unlike many other objects, you never create aMath object of your own. You always use the built-inMath object.

One shortcoming of number values is they only have 64 bits. In practice, due to using IEEE 754 encoding, they cannot represent any integer larger thanNumber.MAX_SAFE_INTEGER (which is 2⁵³ - 1) accurately. To solve the need of encoding binary data and to interoperate with other languages that offer wide integers likei64 (64-bit integers) andi128 (128-bit integers), JavaScript also offers another data type to representarbitrarily large integers:BigInt.

A BigInt can be defined as an integer literal suffixed byn:

const b1 = 123n;// Can be arbitrarily large.const b2 = -1234567890987654321n;

BigInts can also be constructed from number values or string values using theBigInt constructor.

const b1 = BigInt(123);// Using a string prevents loss of precision, since long number// literals don't represent what they seem like.const b2 = BigInt("-1234567890987654321");

Conceptually, a BigInt is just an arbitrarily long sequence of bits which encodes an integer. You can safely do any arithmetic operations without losing precision or over-/underflowing.

const integer = 12 ** 34; // 4.9222352429520264e+36; only has limited precisionconst bigint = 12n ** 34n; // 4922235242952026704037113243122008064n

Compared to numbers, BigInt values yield higher precision when representing largeintegers; however, they cannot representfloating-point numbers. For example, division would round to zero:

const bigintDiv = 5n / 2n; // 2n, because there's no 2.5 in BigInt

Math functions cannot be used on BigInt values; they only work with numbers.

Choosing between BigInt and number depends on your use-case and your input's range. The precision of numbers should be able to accommodate most day-to-day tasks already, and BigInts are most suitable for handling binary data.

Read more about what you can do with BigInt values in theExpressions and Operators section, or theBigInt reference.

JavaScript'sString type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values (UTF-16 code units). Each element in the String occupies a position in the String. The first element is at index 0, the next at index 1, and so on. The length of a String is the number of elements in it. You can create strings using string literals or string objects.

You can declare strings in source code using either single or double quotes:

'foo'"bar"

Within a string literal, most characters can be entered literally. The only exceptions are the backslash (\, which starts an escape sequence), the quote character being used to enclose the string, which terminates the string, and the newline character, which is a syntax error if not preceded by a backslash.

More advanced strings can be created using escape sequences:

Hexadecimal escape sequences

The number after \x is interpreted as ahexadecimal number.

"\xA9" // "©"

Unicode escape sequences

The Unicode escape sequences require at least four hexadecimal digits following\u.

"\u00A9" // "©"

Unicode code point escapes

With Unicode code point escapes, any character can be escaped using hexadecimal numbers so that it is possible to use Unicode code points up to0x10FFFF. With the four-digit Unicode escapes it is often necessary to write the surrogate halves separately to achieve the same result.

See alsoString.fromCodePoint() orString.prototype.codePointAt().

"\u{2F804}"// the same with simple Unicode escapes"\uD87E\uDC04"

You can call methods directly on a string value:

console.log("hello".toUpperCase()); // HELLO

The following methods are available onString values:

• Query: get the character or character code at a particular string index. Methods includeat(),charAt(),charCodeAt(), andcodePointAt().
• Search: get information about a substring that conforms to a pattern, or test if a particular substring exists. Methods includeindexOf(),lastIndexOf(),startsWith(),endsWith(),includes(),match(),matchAll(), andsearch()
• Composition: combine strings into a longer string. Methods includepadStart(),padEnd(),concat(), andrepeat().
• Decomposition: break a string into smaller strings. Methods includesplit(),slice(),substring(),substr(),trim(),trimStart(), andtrimEnd().
• Transformation: return a new string based on the current string's content. Methods includetoLowerCase(),toUpperCase(),toLocaleLowerCase(),toLocaleUpperCase(),normalize(), andtoWellFormed().

When working with strings, there are two other objects that provide important functionality for string manipulation:RegExp andIntl. They are introduced inregular expressions andinternationalization respectively.

Template literals are string literals allowing embedded expressions. You can use multi-line strings and string interpolation features with them.

Template literals are enclosed by backtick (grave accent) characters (`) instead of double or single quotes. Template literals can contain placeholders. These are indicated by the dollar sign and curly braces (${expression}).

Any new line characters inserted in the source are part of the template literal. Using normal strings, you would have to use the following syntax in order to get multi-line strings:

console.log(  "string text line 1\n\string text line 2",);// "string text line 1// string text line 2"

To get the same effect with multi-line strings, you can now write:

console.log(`string text line 1string text line 2`);// "string text line 1// string text line 2"

In order to embed expressions within normal strings, you would use the following syntax:

const five = 5;const ten = 10;console.log(  "Fifteen is " + (five + ten) + " and not " + (2 * five + ten) + ".",);// "Fifteen is 15 and not 20."

Now, with template literals, you are able to make use of the syntactic sugar making substitutions like this more readable:

const five = 5;const ten = 10;console.log(`Fifteen is ${five + ten} and not ${2 * five + ten}.`);// "Fifteen is 15 and not 20."

For more information, read aboutTemplate literals in theJavaScript reference.

• Previous
• Next