TIPE DATA PADA JAVASCRIPT : ANGKA

Summary

In this tutorial, Sandika Gali dives into JavaScript's number data type, explaining how numbers are represented as 64-bit floating-point values. He clarifies the absence of a specific integer type and the potential precision issues with large numbers. The video also covers handling decimal numbers, the importance of using a period for decimals, and working with exponents for large or small numbers. Sandika highlights special values like Infinity and NaN, warning users about pitfalls like leading zeros and string operations that can affect calculations. This lesson sets the foundation for understanding numbers in JavaScript before moving on to operations in future videos.

Takeaways

• 😀 JavaScript uses double-precision floating-point format for all numbers, meaning there are no distinct integer types.
• 😀 Numbers in JavaScript are represented as floating-point values, including whole numbers, which may lose precision beyond 15 digits.
• 😀 JavaScript numbers support decimals, but decimals should be written with a period (e.g., `3.14`, `0.5`) instead of a comma.
• 😀 Arithmetic with floating-point numbers can lead to precision issues. For example, `0.1 + 0.2` may not exactly equal `0.3`.
• 😀 Exponential notation (`e` or `E`) can be used for large or small numbers, such as `1e5` for `100000` or `1e-5` for `0.00001`.
• 😀 Negative numbers are represented by placing a minus sign in front of the value, like `-25`.
• 😀 Special values in JavaScript include `Infinity`, `-Infinity`, and `NaN` (Not-a-Number), which are returned in specific operations.
• 😀 `Infinity` results from dividing a positive number by zero, and `-Infinity` comes from dividing a negative number by zero.
• 😀 `NaN` is returned when operations like `0 / 0` or dividing a number by a string occur, indicating an invalid result.
• 😀 Numbers with a leading `0` (e.g., `022`) are interpreted as octal (base-8) numbers, which could lead to unexpected results like `18` instead of `22`.
• 😀 Hexadecimal numbers in JavaScript start with `0x` (e.g., `0xff`), and are interpreted as base-16 values, with `0xff` equal to `255`.

Q & A

What is the number data type in JavaScript?

In JavaScript, numbers are represented using a 64-bit double precision floating point format, which means there is no distinct integer type. Instead, all numbers are floating-point numbers.

Why is JavaScript using floating-point representation for numbers instead of integers?

JavaScript uses floating-point representation for all numbers because it follows the IEEE 754 standard for representing numerical data, which allows for flexibility in handling both large and small values, but it doesn't distinguish between integers and floats.

What is the maximum number JavaScript can handle?

JavaScript can handle numbers up to approximately 1.8 * 10^19, or 18 quintillion, due to the 64-bit limit on number size.

What happens when you input a number larger than 15 digits in JavaScript?

When you input a number larger than 15 digits in JavaScript, the number is rounded due to the floating-point representation, which can only accurately handle up to 15 digits.

How does JavaScript handle decimal points in numbers?

In JavaScript, decimal points are represented using a dot (e.g., 3.14, 0.5). JavaScript supports up to 17 digits after the decimal point, but calculations involving floating-point numbers may introduce rounding errors.

What is the issue with adding 0.2 and 0.1 in JavaScript?

In JavaScript, when you add 0.2 and 0.1, the result is not exactly 0.3 due to the imprecision of floating-point arithmetic. The result may be something like 0.30000000000000004.

How does JavaScript handle very large or small numbers using exponents?

JavaScript can represent very large or small numbers using scientific notation, or exponents. For example, 12,300,000 can be written as 1.23e7, and very small numbers can be written with negative exponents.

What is the significance of negative numbers in JavaScript's number representation?

In JavaScript, negative numbers are represented by one of the 64-bit bits as a sign bit to indicate whether the number is positive or negative.

What is the result of dividing a number by zero in JavaScript?

In JavaScript, dividing a positive number by zero results in 'Infinity', and dividing a negative number by zero results in '-Infinity'. Dividing zero by zero results in 'NaN' (Not a Number).

What is the meaning of 'NaN' in JavaScript?

'NaN' stands for 'Not a Number'. It is returned when an operation results in an undefined or unrepresentable value, such as dividing zero by zero or performing operations involving strings that can't be converted to numbers.