# Numbers in JavaScript by [kirupa](https://www.kirupa.com/me/index.htm) | filed under [JavaScript 101](https://www.kirupa.com/javascript/learn_javascript.htm) A large part of our time in JavaScript will be spent dealing with numbers. Even if we aren’t working with numbers directly, we’ll indirectly encounter them when doing even the most basic of tasks such as keeping count of something, working with arrays, etc. In this tutorial, I will provide an introduction to numbers in JavaScript by looking at how you can use them to accomplish many common tasks. Along the way, we will dive a little bit beyond the basics to broadly explore some interesting number-related things you might find useful. Onwards! ## Using a Number In order to use a number, all we have to do is…well, use it. Below is a simple example of us declaring a variable called `stooges` that is initialized to the number 3: ```js let stooges = 3; ``` That is it. There are no hoops to jump through. If we wanted to use more complex numbers, we can just use them as if nothing is different: ```js let pi = 3.14159; let color = 0xFF; let massOfEarth = 5.9742e+24; ``` In the above example, we are using a decimal value, a hexadecimal value, and a really large value using exponents. In the end, our browser will automatically do the right thing. Note that the "right thing" doesn't just exist in the positive space. We can use negative numbers easily as well. To use negative numbers, just place a minus (`-`) character before the number we want to turn into a negative value: ```js let temperature = -42; ``` What we've seen in this section makes up the bulk of how we will actually use numbers. In the next couple of sections, let's go a little bit deeper and look at some of the other interesting things we can do with them. #### Trivia: Numbers in JavaScript If you are curious why working with numbers is so easy, the reason is because JavaScript isn’t big on numerical types. You don’t have to declare a number as being of type `int`, `double`, `byte`, `float`, etc. like you may have had to do in other languages. The only exception is if you need a really large or really small number, and that is when `BigInt` comes in. We will talk about `BigInt` later...someday. Oh, also...in JavaScript, all numbers are converted into 64-bit floating point numbers. ## Operators No introduction to numbers would be complete (…or started) without showing you how we can use mathematical operators in code to implement things we learned in first-grade Math class. Let's look at the common operators in this section. ### Doing Simple Math In JavaScript, we can create simple mathematical expressions using the +, -, *, /, and % operators to add, subtract, multiply, divide, and find the remainder (modulus) of numbers respectively. If you can use a calculator, you can do simple math in JavaScript. Here are some examples that put these operators to use: ```js let total = 4 + 26; let average = total / 2; let doublePi = 2*3.14159; let subtractItem = 50 – 25; let remainder = total % 7; let more = (1 + average * 10) / 5; ``` In the last line in the above example, notice that we are defining a particular order of operations by using parenthesis around the expression I want to evaluate as a group. Again, all of this is just calculator stuff. JavaScript evaluates expressions in the following order: 1. Parenthesis 1. Exponents 1. Multiply 1. Divide 1. Add 1. Subtract There are various mnemonic devices out there to help you remember this. The one I grew up with since elementary school is "**P**lease **E**xcuse **M**y **D**ear **A**unt **S**ally." ## Incrementing and Decrementing A common thing you will do with numbers will involve incrementing or decrementing a variable by a certain amount. Below is an example of me incrementing the variable `i` by 1: ```js let i = 4; i = i + 1; ``` You don’t have to increment or decrement by just 1. You can use any arbitrary number: ```js let i = 100; i = i - 2; ``` All of this doesn’t just have to just be addition or subtraction. You can perform other operations as well: ```js let i = 100; i = i / 2; ``` You should start to see a pattern here. Regardless of what operator you are using, you’ll notice that you are cumulatively modifying your `i` variable. Because of how frequently you will use this pattern, you have some operators that simplify this a bit. If I use these operators on the three examples you saw earlier, the code will look as follows: ```js i++; i -= 2; i /= 2; ``` Before we wrap this up, there is one quirk you should be aware of. It has to do with the `--` and `++` operators for incrementing or decrementing a value by 1. It matters,whether the `++` and `--` operators appear before or after the variable they are incrementing or decrementing. Let’s look at this example: ```js let i = 4; let j = i++; ``` After executing these two lines, the value of `i` will be 5...just like you would expect. The value of `j` will be 4. Notice that in this example, the operator appears after the variable. If we place the operator in front of the variable, the results are a bit different: ```js let i = 4; let j = ++i; ``` The value of `i` will still be 5. Here is the kicker...the value of `j` will be 5 also. What changed between these two examples is the position of the operator. The position of the operator determines **whether the incremented value will be returned or the pre-incremented value will be returned**. Now, aren't you glad you learned that? ## Hexadecimal and Octal Values Beyond using normal decimal values, you can use hexadecimal (base 16) and octal (base 8) values as well. When working with octal values, make sure to start your number with a 0: ```js let leet = 02471; ``` For hexadecimal values, you need start your number with 0x: ```js let leet = 0x539; ``` In many situations, you'll find yourself dealing with octal and hexadecimal values in the form of strings. If they are strings, you cannot manipulate them as you would normal numbers. You need to convert the string to a number first. The way you do that is by using the `parseInt` function: ```js let hexValue = parseInt('FFFFFF', 16); let octalValue = parseInt('011', 8); ``` The `parseInt` function takes your hexadecimal or octal value followed by the base you are converting from. ## Special Values - Infinity and NaN The last thing we will look at are two global properties that you will encounter that aren't numerical values. These values are `Infinity` and ` NaN`. ### Infinity You can use the `Infinity` and `–Infinity` values to define infinitely large or small numbers: ```js let myLoveForYou = Infinity * 2; ``` The chances of you having to use `Infinity` are often very slim. Instead, you will probably see it returned as part of something else your code does. For example, you will see `Infinity` returned if you divide by 0. ### NaN The `NaN` keyword stands for "Not a Number", and it gets returned when you do some numerical operation that is invalid. For example, `NaN` gets returned in the following case: ```js let nope = 1920 / "blah"; ``` The reason is that you cannot divide a number and a string. There are non-contrived cases where you will see this value returned, and we'll look at some later. #### Going from a String to a Number Sometimes, you will have numbers that are buried inside Strings. To get all the scoop on that, read the [ Going from a String to a Number](https://www.kirupa.com/html5/going_from_a_string_to_a_number.htm) tutorial. ## The Math Object Numbers are used in a variety of mathematical expressions, and they often go beyond simple additions, subtractions, multiplications, and divisions. Your math classes back in the day would have been a whole lot easier if that's all there was to it. To help you more easily do complicated numerical things, you have the `Math` object. This object provides you with a lot of functions and constants that will come in handy, and we are going to very briefly look at some of the things this object does. #### This is Boring! I am not going to lie to you. Looking at all the stuff the `Math` object provides is pretty boring. Unless you really want to know about all of this now, I would prefer you just very VERY quickly skim through the following sections and refer back as needed. The `Math` object isn't going anywhere (it has no friends), so it will be waiting for you at a later time. ### The Constants To avoid you having to explicitly define mathematical constants like pi, Euler's constant, natural log, and so on, the `Math` object defines many common constants for you: Of all of these constants, the one I've used the most is `Math.PI`: ![](https://www.kirupa.com/html5/images/PI_72.jpg) You will use this in everything from drawing circles on your screen to specifying trigonometric expressions. In fact, I can't ever remember having used any of these other constants outside of `Math.PI`. Here is an example of a function that returns the circumference given the radius: ```js function getCircumference(radius) { return 2 * Math.PI * radius; } alert(getCircumference(2)); ``` You would use `Math.PI` or any other constant just as you would any named variable. ### Rounding Numbers Your numbers will often end up containing a ridiculous amount of precision: ```js let position = getPositionFromCursor(); // 159.3634493939 ``` To help you round these numbers up to a reasonable integer value, you have the `Math.round()`, `Math.ceil()`, and `Math.floor()` functions that take a number as an argument: The easiest way to make sense of the above table is to just see these three functions in action: ```js Math.floor(.5) // 0 Math.ceil(.5) // 1 Math.round(.5) // 1 Math.floor(3.14) // 3 Math.round(3.14) // 3 Math.ceil(3.14) // 4 Math.floor(5.9) // 5 Math.round(5.9) // 6 Math.ceil(5.9) // 6 ``` These three functions always round you to an integer. If you want to round to a precise set of digits, check out the last half of my [ Rounding Numbers in JavaScript](https://www.kirupa.com/html5/rounding_numbers_in_javascript.htm) tutorial. ### Trigonometric Functions My favorite of the functions, the `Math` object gives you handy access to almost all of the trigonometric functions you will need: To use any of these, just pass in a number as the argument: ```js Math.cos(0) //1 Math.sin(0) //0 Math.tan(Math.PI / 4) //1 Math.cos(Math.PI) //1 Math.cos(4 * Math.PI) //1 ``` These trigonometric functions take arguments in the form of radian values. If your numbers are in the form of degrees, be sure to convert them to radians first. ### Powers and Square Roots Continuing down the path of defining the ` Math` object functions, you have ` Math.pow()`, `Math.exp()`, and `Math.sqrt()`: Let's look at some examples: ```js Math.pow(2, 4) //equivalent of 2^4 (or 2 * 2 * 2 * 2) Math.exp(3) //equivalent of Math.E^3 Math.sqrt(16) //4 ``` Note that `Math.pow()` takes two arguments. This might be the first built-in function we've looked at that takes two arguments. This little detail is somehow mildly exciting. ### Getting the Absolute Value If you want the absolute value of a number, simply use the `Math.abs()` function: ```js Math.abs(37) //37 Math.abs(-6) //6 ``` That's all I got for this. ## Random Numbers To generate a somewhat random number between 0 and a smidgen less than 1, you have the `Math.random()` function. This function doesn't take any arguments, but you can simply use it as part of a mathematical expression: ```js let randomNumber = Math.random() * 100; ``` Each time your `Math.random` function is called, you will see a different number returned for `Math.random()`. To learn all about how to work with this function to generate random numbers, read the [ Random Numbers in JS](https://www.kirupa.com/html5/random_numbers_js.htm) tutorial. ## Conclusion That's all there is to it for this introductory tutorial on numbers and the `Math` object in JavaScript. As you could see, it doesn't get much easier. JavaScript provides a very no-frills approach to working with them, and this tutorial gave you a slight peek at the edges in case you needed to go there.