Unlimited Plugins, WordPress themes, videos & courses! Unlimited asset downloads! From $16.50/m

Next lesson playing in 5 seconds

Cancel
  • Overview
  • Transcript

5.3 Working With Numbers

In this lesson we’ll take a look at some of the properties and methods that make up the API of the built-in Number object.

Syntax

  • isNaN
  • parseFloat
  • parseInt
  • toFixed
  • toExponential
  • toPrecision
  • toString

1.Introduction
2 lessons, 07:42

1.1
Introduction
02:12

1.2
Setup
05:30

2.Language Fundamentals
8 lessons, 1:00:53

2.1
Variables
06:33

2.2
Data Types
11:28

2.3
Arithmetic, Assignment, and Comparison Operators
10:24

2.4
Unary, Logical, Comma, and Spread Operators
09:02

2.5
Operator Precedence
03:50

2.6
Reserved Words
04:17

2.7
Strict Mode
04:34

2.8
Functions
10:45

3.Data Structures
5 lessons, 22:52

3.1
Arrays
04:29

3.2
Objects
04:30

3.3
Sets
04:57

3.4
Maps
04:21

3.5
Weak Maps and Weak Sets
04:35

4.Controlling Program Execution
7 lessons, 37:06

4.1
Conditionals
07:49

4.2
Switch Statements
04:41

4.3
The For Loop
06:39

4.4
The `for .. in` Loop
05:17

4.5
The `for .. of` Loop
04:02

4.6
Iterators
05:03

4.7
While Loops
03:35

5.Using JavaScript
13 lessons, 1:44:36

5.1
Working With Strings
09:32

5.2
Template Literals
05:46

5.3
Working With Numbers
06:57

5.4
Working With Arrays
12:53

5.5
Iterating and Transforming Arrays
07:33

5.6
Working With the Object Type
13:55

5.7
Object Literal Extensions
06:45

5.8
Working With Object Instances
06:45

5.9
Getters and Setters
05:00

5.10
Custom Objects
11:28

5.11
The `Math` API
04:54

5.12
Working With Dates and Times
08:10

5.13
The `Array` Constructor
04:58

6.Functions
8 lessons, 56:07

6.1
The `this` Object
06:15

6.2
Working With Functions
10:11

6.3
Scope
07:37

6.4
Arrow Functions
06:59

6.5
Generator Functions
08:13

6.6
Closures
05:00

6.7
Prototypes
06:26

6.8
Default and Rest Parameters
05:26

7.Miscellaneous
6 lessons, 52:39

7.1
Destructuring Assignments
08:09

7.2
AJAX
08:30

7.3
Regular Expressions
10:51

7.4
More About Regular Expressions
08:38

7.5
Classes
06:48

7.6
ES Modules
09:43

8.Working With the DOM
6 lessons, 37:39

8.1
Selecting HTML Elements
05:02

8.2
Manipulating HTML Elements
07:40

8.3
DOM Traversal
05:25

8.4
Adding and Removing Elements
04:45

8.5
Creating Elements and Other Nodes
04:39

8.6
DOM Events
10:08

9.Web APIs
4 lessons, 17:41

9.1
The Selector API
03:03

9.2
Geolocation
05:29

9.3
Web Storage
05:24

9.4
Web Workers
03:45

10.Asynchronous JavaScript
5 lessons, 26:23

10.1
Promises
09:52

10.2
Promise Chaining
05:11

10.3
The async Keyword
03:21

10.4
The await Keyword
04:04

10.5
More About async and await
03:55

11.Conclusion
1 lesson, 00:43

11.1
Conclusion
00:43


5.3 Working With Numbers

Hey folks, in this lesson we're going to look at numbers. Like strings, numbers are another type of primitive. And also like strings, they have a number of properties and methods for working with them. And that's what we're going to focus on today. The number object contain some properties that present different values in JavaScript. Like max_value, min_value, max_safe_integer, and min_safe_integer, which are the maximum and minimum values and safe values that it is possible to use in JavaScript. There are also some very useful methods. There is a special number in JavaScript called NaN, which is produced when we try to do something with a number which is not possible. Like multiplying it by a string. The problem with NaN values is that they ruin any mathematical calculations that you are trying to perform. And they are very hard to detect. Because NaN is not equal to anything, not even itself, so this makes it very hard to test for in a conditional. To overcome this, we have the isNaN method, which we can use to detect when a value is NaN. Let's take a look. And lets check the output now in our browser. And we can see that, that has resulted in the value of true. So, isNaN is a static method which is invoked directly on the number object rather than on number instances. We also have these static methods isFinite, isInteger, and isSafeInteger for performing others checks on numbers. The last two static methods are very commonly used. If we want to convert strings into numbers, there are two more static methods that we can make use of. parseFloat for parsing floating point numbers from strings, and parseInt, for parsingintegers. Let's take a look at how these two work. So here we've defined two strings which happen to contain numbers. Let's convert them directly into numbers instead of strings. So they look like numbers, but let's use the typeof operator just to be certain. And we can see that they are both numbers. The strings that we're parsing from don't have to just contain numbers, they can also contain numbers and letters. And these two methods should still work in the same way depending on where the numbers occur. And we can see that we have still managed to extract the numbers from those strings, even though the strings contain more than just numbers. However, in order to parse numbers successfully from strings, the numbers need to come at the start of the string. So when we add non numerical numbers to the start of a string, before any numbers occur, and try to parse those numbers out of it, we'll get the value not a number. And just to highlight how dangerous the not a number or NAN value is, let's just go back and add typeof again to the start of the first console log. And it misleadingly tells us that we're still working with a number, because the NAN value is a type of number. So we have to be very careful when parsing numbers from strings to make sure that we don't end up with this NAN value. As well as the static methods that we've looked at so far, number instances also have several methods that can be used to work with the number in some way. For example, to convert a number to have a specific number of decimal places, we can use the toFixed method So we've invoked the toFixed method on our number instance, and we've passed it the argument 2. So it should truncate the number down to two decimal places. Let's just check the output in our browser. And as you can see, that has worked. And the rounding that has occurred is probably what you would expect from regular mathematics. As well as toFixed, we also have toExponential, toLocaleString, toPrecision, and toString methods. The toFixed and toPrecision methods are very similar. The difference between them is that toFixed rounds to a fixed number of decimal places while toPrecision formats a number to a given number of significant digits. So in this lesson we looked at numbers. We saw the static properties and methods that we can use from the number object directly. And we also saw some of the instance methods that we can use with number instances. In the next lesson, we'll move on to look at how we can work with arrays. Thanks for watching.

Back to the top