Now let's look at the floor method (translated as gender) which works the opposite of the ceil method, i.e. he rounds down a fractional number.
As you can see, the floor method rounded 35.97 down to 35, which is downward. Even though 0.97 is greater than 0.5 (cm. ).
This lesson covered the methods of the Math object, allowing fractional decimal numbers to be rounded.
Now you need to do your homework.
Your task is to write a function that takes two parameters.
1. An array consisting of numbers with fractions.
2. Rounding method "round", "ceil" or "floor".
At the output, the function should output the same array, but all array elements must be rounded using the method specified in the second parameter of the Math object.
Source array:
var numberArray =;
At first, the solution to this problem may seem almost identical to the solutions to the household problems in the first three lessons of this topic. But not everything is so simple ...
Solution # 1 - Attention
By the condition of the problem the function must take two parameters- the original array and one of the methods: "round", "ceil" or "floor". Based on this, I tried to do so...
In this solution, we create a function with two parameters, and when we call it, we try to specify the original array and the NAME of one method as the function parameters:
decimal (numberArray, round) - in this case round.
But we will not get the result, since DO NOT specify a method NAME as a function parameter.
Please note: it is no coincidence that the names of the methods "round", "ceil" and "floor" in the problem statement quoted.
decimal (numberArray, "round") - but this will not be correct either !!!
Solution # 2 - Correct the previous solution
You can solve the problem by specifying one parameter for the function.
35 - Rounded element
13 - Rounded element
17 - Rounded element
79 - Rounded element
Here we managed to achieve the desired result: the round method rounded all numbers by. But condition is not met since the function only takes one parameter.
Solution # 3 - Function with two parameters
Here the problem is solved correctly. To do this, you had to remember the topic of conditions in javascript and apply several conditions at the same time.
34.82 - the original element of the array
35 - round up
12.9 - the original element of the array
13 - round up
17.01 - the original element of the array
18 - round up
78.51 - the original element of the array
79 - round up
it correct solution Homework. Here two parameters are specified for the function according to the condition.
Try on the last line of this solution:
decimal (numberArray, "ceil") as the second parameter of the function, specify the names of other methods "round" and "floor" of the Math object.
Solution # 4 - Function with two parameters + prompt method
I decided to optimize the previous solution a bit and added a prompt method that calls modal window containing a field for entering information.
Now, thanks to this, it will be possible to enter the name of one of the methods round, floor or ceil in the input field and get the corresponding result.
This is how the round, floor, or ceil methods of the Math object work, which round off fractional numbers.
Calculations often produce results that fall outside the desired ranges. As a result, you need to carry out JavaScript rounding to a certain value.
Why round off numbers?
JavaScript does not store integers because their values are represented as floating point numbers. Many fractions cannot be represented by a finite number of decimal places, so JavaScript can generate results like the one below:
0.1 * 0.2; > 0.020000000000000004
In practice, this will not make any difference, since we are talking about an error of 2 quintillion. However, this can affect the result when working with numbers that represent currency values, percentages, or file size. Therefore, you need to do or to a certain decimal place.
Rounding decimal numbers
To "trim" a decimal number, use the toFixed () or toPrecision () methods. They both take one argument, which specifies the number of significant and decimal places to be included in the result:
- if no argument is specified for toFixed (), the default is 0, that is, no decimal places; the maximum value of the argument is 20;
- if no argument is specified for toPrecision (), the number is not changed.
var randNum = 6.25; randNum.toFixed (); > "6" Math.PI.toPrecision (1); > "3" var randNum = 87.335; randNum.toFixed (2); > "87.33" var randNum = 87.337; randNum.toPrecision (3); > "87.3"
Note
Both toFixed () and toPrecision return a rounded string representation of the result, not a number. This means that adding rounded to randNum will result in string concatenation rather than a single number:
console.log (randNum + rounded); > "6.256"
If you want JavaScript to round to the nearest hundredth, use parseFloat ():
var randNum = 6.25; var rounded = parseFloat (randNum.toFixed (1)); console.log (rounded); > 6.3
toFixed () and toPrecision () are also useful methods for truncating large numbers of decimal places. This is useful when working with numbers that represent monetary units:
var wholeNum = 1 var dollarsCents = wholeNum.toFixed (2); console.log (dollarsCents); > "1.00"
Note that if there are more digits in the number than specified by the precision parameter, toPrecision will return the result in scientific format:
var num = 123.435 num.toPrecision (2); > "1.2e + 2"
How to avoid errors when rounding decimal fractions
In some cases, toFixed and toPrecision implement JavaScript rounding down 5, and not to more:
var numTest = 1.005; numTest.toFixed (2); > 1;
The above example should result in 1.01, not 1. If you need to avoid this error, I recommend using exponential numbers:
function round (value, decimals) (return Number (Math.round (value + "e" + decimals) + "e -" + decimals);)
Application:
round (1.005.2); > 1.01
If you need an even more reliable solution than rounding, it is available at MDN.
Epsilon rounding
Alternative method JavaScript rounding to tenths was introduced in ES6 ( also known as JavaScript 2015). « Machine epsilon»Provides a reasonable margin of error when comparing two floating point numbers. Without rounding, comparisons can produce results similar to the following:
0.1 + 0.2 === 0.3> false
Math.EPSILON can be used in a function to get a correct comparison:
function epsEqu (x, y) (return Math.abs (x - y)< Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }
The function takes two arguments: one contains calculations, the second is the expected (rounded) result. It returns a comparison of these two parameters:
epsEqu (0.1 + 0.2, 0.3)> true
All modern browsers support ES6 math functions. But if you need to provide support in older browsers, then you need to use polyfills.
Truncating decimal numbers
All methods presented earlier perform JavaScript rounding to tenths... To truncate a positive number to two decimal places, multiply it by 100, truncate it again, and then divide the result by 100, you need:
function truncated (num) (return Math.trunc (num * 100) / 100;) truncated (3.1416)> 3.14
If you need something more flexible, you can use the bitwise operator:
function truncated (num, decimalPlaces) (var numPowerConverter = Math.pow (10, decimalPlaces); return ~~ (num * numPowerConverter) / numPowerConverter;)
Usage:
var randInt = 35.874993; truncated (randInt, 3); > 35.874
Rounding to the nearest number
To carry out JavaScript rounding to integer, used by Math.round ():
Math.round (4.3)> 4 Math.round (4.5)> 5
Note that " half values“Such as .5 are rounded up.
Round down to the nearest whole number
If you want to round down, use the Math.floor () method:
Math.floor (42.23); > 42 Math.floor (36.93); > 36
Rounding down has one direction for all numbers, including negative ones. This can be imagined as a skyscraper with an infinite number of floors, including below the level of the foundation ( representing negative numbers). If you are in the elevator between basement floors 2 and 3 ( which corresponds to a value of -2.5), Math.floor will take you to floor -3:
Math.floor (-2.5); > -3
If you need to avoid this, use JavaScript Math rounding with Math.trunc (), which is supported in all modern browsers(except IE / Edge):
Math.trunc (-41.43); > -41
MDN also provides 3 line polyfill to provide Math.trunc support in older browsers and IE / Edge.
Round up to the nearest whole number
If you want to round up decimals, use Math.ceil. This method can also be thought of as an endless lift: Math.ceil always takes you up, regardless of whether the number is negative or positive:
Math.ceil (42.23); > 43 Math.ceil (36.93); > 37 Math.ceil (-36.93); -36
Rounding to the nearest multiple
If you need to round a value to the nearest multiple of 5, create a function that divides the number by 5, rounds it, and then multiplies the result by the same value:
function roundTo5 (num) (return Math.round (num / 5) * 5;)
Usage:
roundTo5 (11); > 10
If you need JavaScript to round to two digits, you can pass both the initial number and the multiplicity to the function:
function roundToMultiple (num, multiple) (return Math.round (num / multiple) * multiple;)
To use the function, include the number to be rounded and the multiplicity in its call:
var initialNumber = 11; var multiple = 10; roundToMultiple (initialNumber, multiple); > 10;
To round values only up or down, replace round with ceil or floor in the function.
Range snapping
Sometimes you need to get the value of x, which must be within a certain range. For example, we need a value between 1 and 100, but we get a value of 123. To fix this, one can use min () ( returns the smallest of the numbers) and max ( returns the maximum number allowed).
Usage:
var lowBound = 1; var highBound = 100; var numInput = 123; var clamped = Math.max (lowBound, Math.min (numInput, highBound)); console.log (clamped); > 100;
You can create a function or extension of the Number class.
Hello JavaScript lovers. You have already noticed that this language is very unusual and in each section stands out for its peculiarities and unusual technical solutions. Therefore, today's post is devoted to the topic: "JavaScript rounding".
After reading the current article, you will learn why it is necessary to round numbers, which methods and properties in js perform this function, and also how division by 0 stands out. Without changing my principles, I will attach examples to the key points of the material and describe each action in detail. Now let's start learning!
Important notes about numbers
First, remember that in js all kinds of numbers (fractions and integers) are of the type Number... In addition, they are all 64-bit, since they are stored in the "double precision" format, which is also known as the IEEE-754 standard.
Numeric variables are created in the usual way:
var numb = 35; // natural number
var drob = 0.93; // decimal representation
var numb16 = 0xFF; // hexadecimal number system
Supports other numeric representations as well. So, you can still create floating point numbers (they are also sometimes called "numbers in scientific format").
The support appeared very interesting method toLocaleString (), which formats all numeric parameters according to the specifications written in ECMA 402. Due to this large numbers, phone numbers, currencies and even interest are displayed beautifully in the dialog box.
var num = 714000.80;
alert (num.toLocaleString ());
To work with elements of type Number, a whole global object was provided with a bunch of all kinds of mathematical functions, the name of which is Math.
In addition, there are other methods that round off numeric values to whole numbers, tenths, hundredths, etc. Let's consider all of them in more detail.
Great and mighty Math
The global Math object includes a wide variety of mathematical and trigonometric functions. This is a very useful object and often helps developers when working with digital data.
On other platforms, there are analogies for Math. For example, in popular languages like Java and C #, Math is a class that supports all of the same standard functionality. So as you can see, this instrument is really great and powerful.
Now I want to walk on specific methods, responsible for rounding, and tell them in detail.
Math.floor ()
I'll start with Math.floor... Pay attention to the name of the method. Logically, it becomes clear that since we are talking about rounding, and the literal translation of the word "floor" means "floor", then this tool will round the processed values downward.
It is also possible that the processed number using this function remains the same. This is because rounding is carried out according to a non-strict inequality (<=). Таким образом, при отработке этой строчки кода:
alert (Math.floor (4.5));
the answer will be the number 4.
Math.ceil ()
Again, look at the name (in this way, the material is absorbed faster). If someone doesn't know, ceil means ceiling. This means that numerical data will be rounded up, using a loose inequality (> =).
alert (Math.ceil (4.5));
As you may have guessed, the answer will be the number 5.
Math.round ()
This method rounds the fractional number to the nearest integer. So, if the fractional part is in the range from 0 to 0.5, not inclusive, then rounding down occurs. And if the fractional part is in the range from inclusively 0.5 to the next integer, then it is rounded up to the larger integer.
alert (Math.round (4.5));
I hope everyone thought or said the correct answer - 5.
A few more methods
JavaScript also has 2 other methods that deal with rounding of numeric representations. However, they are somewhat different.
It will be about tools such as toFixed () and toPrecision ()... They are responsible not only for rounding, but for its accuracy to certain signs. Let's dig deeper.
toFixed ()
Using this mechanism, you can specify to how many decimal places the value should be rounded. The method returns the result as a string. Below I have attached a variant with three different variants. Analyze the answers you received.
var num = 5656.9393;
document.writeln (num.toFixed ()); // 5657
document.writeln (num.toFixed (2)); // 5656.94
document.writeln (num.toFixed (7)); // 5656.9393000
As you can see, if you do not specify an argument, then toFixed ()) will round the fractional value to the whole numbers. The third line is rounded up to 2 characters, and in the fourth - because of the "7" parameter, three more 0s were added.
toPrecision ()
This method works in a slightly different way. In place of the argument, you can leave either an empty space or set a parameter. However, the latter will round numbers to the specified number of digits, ignoring the comma. Here are the results of the program rewritten from the previous example:
var num = 5656.9393;
document.writeln (num.toPrecision ()); // 5656.9393
document.writeln (num.toPrecision (2)); // 5.7e + 3
document.writeln (num.toPrecision (7)); // 5656.939
The division by 0 feature in js
As you know from math lessons, you cannot divide by zero. This rule was taken as a basis by most of the creators of programming languages. Therefore, when divided by zero, all programs generate an error.
However, JavaScript has distinguished itself here too. So, during the execution of such an operation, no error messages appear ... because such an operation returns "Infinity"!
Why is it so? As you know from the same mathematical sciences, the smaller the divisor, the result is more... That is why the creators of this prototype-oriented language decided to abandon templates and go their own way.
For those who first encounter the Infinity value, below I explained its features.
Infinity - means infinity and fully corresponds to the mathematical sign ∞.
It could be negative. All standard rules for working with arithmetic operators are also preserved.
alert (12/0); // Infinity
alert (12.34 / 0); // Infinity
alert (-3 / 0); // -Infinity
On this, perhaps, I will finish. If you liked the publication, then be sure to subscribe to my blog. Do not be greedy with links to interesting articles and share them with your friends. Bye Bye!
This article will take a closer look at numbers, mathematical operators, ways to convert a number to a string and vice versa, as well as many other important points.
IsFinite function
The isFinite function allows you to check if an argument is finite.
As an answer this function returns false if the argument is Infinity, -Infinity, NaN, or will be cast to one of these special numeric values. Otherwise, this function will return true.
IsFinite (73); // true isFinite (-1/0); // false isFinite (Infinity); // false isFinite (NaN); // false isFinite ("Text"); // false
except global function isFinite JavaScript also has a Number.isFinite method. Unlike isFinite, it does not force the argument to a number.
IsFinite ("73"); // true Number.isFinite ("73"); // false
IsNaN function
The isNaN function is designed to determine if an argument is a number or can be converted to it. If so, then the isNaN function returns false. Otherwise, it returns true.
IsNaN (NaN); // true isNaN ("25px"); // true, because 20px is not a number isNaN (25.5); // false isNaN ("25.5"); // false isNaN (""); // false, because space or several spaces are converted to 0 isNaN (null); // false, because null is converted to 0 isNaN (true); // false, because true is converted to 1 isNaN (false); // false, because false converts to 0
If this action needs to be performed without typecasting, then use the Number.isNaN method. This method has been introduced into the language since ECMAScript 6.
How can I explicitly convert a string to a number?
You can explicitly convert a string to a number using the following methods:
1. Use unary + operator to be placed before the value.
+ "7.35"; // 7.35 + "text"; // NaN
This method ignores leading and trailing whitespace and \ n (line feed).
+ "7.35"; //7.35 + "7.35 \ n"; //7.35
Using this way it is necessary to pay attention to the fact that empty line or a string consisting of spaces and \ n is converted to 0. In addition, it also converts the data type to null and boolean values to the number.
Null; // 0 + true; // 1 + false; // 0 + ""; // 0
2. The parseInt function. This function is designed to convert argument to an integer... As opposed to using unary operator +, this method allows you to convert a string to a number, in which not all characters are numeric... It starts converting the string, starting at the first character. And as soon as it encounters a non-numeric character, this function stops its work and returns the resulting number.
ParseInt ("18px"); // 18 parseInt ("33.3%"); // 33
This function can work with different number systems (binary, octal, decimal, hexadecimal). The radix is specified using 2 arguments.
ParseInt ("18px", 10); // 18 parseInt ("33.3%", 10); // 33 parseInt ("101", 2); // 5 parseInt ("B5", 16); // 181
In addition to the parseInt function, JavaScript has a Number.parseInt method. This method is no different from the parseInt function and was introduced in JavaScript with the ECMASCRIPT 2015 specification (6).
3. The parseFloat function. ParseFloat is similar to parseInt, except that it converts the argument to a fraction.
ParseFloat ("33.3%"); //33.3
In addition, the parseFloat function, unlike parseInt, does not have 2 arguments, and therefore it always tries to treat the string as a decimal number.
ParseFloat ("3.14"); parseFloat ("314e-2"); parseFloat ("0.0314E + 2");
In addition to the parseFloat function, JavaScript has a Number.parseFloat method. This method is no different from the parseFloat function and was introduced in JavaScript with the ECMASCRIPT 2015 specification (6).
Convert number to string
You can convert a number to a string using the toString method.
(12.8) .toString (); //"12.8 "
The toString method also allows you to specify the base of the number system, taking into account which it is necessary to explicitly cast the number to a string:
(255) .toString (16); // "ff"
How to check if a variable is a number
You can determine if the value of a variable is a number using one of the following methods:
1.Using the isNaN and isFinite functions:
// myVar is a variable if (! isNaN (parseFloat (myVar)) && isFinite (parseFloat (myVar))) (// myVar is a number or can be cast to it);
As a function:
// function function isNumeric (value) (return! isNaN (parseFloat (value)) && isFinite (parseFloat (value));) // use var myVar = "12px"; console.log (isNumeric (myVar)); // true
This method allows you to determine whether specified value number or can be reduced to it. This option does not treat an empty string, a string of spaces, null, Infinity, -Infinity, true or false as a number.
2.Using operator typeof and functions isFinite, isNaN:
// function that checks if the value is a number function isNumber (value) (return typeof value === "(! LANG: number" && isFinite(value) && !isNaN(value); }; // использование функции isNumber isNumber(18); //true // использование функций для проверки текстовых значений isNumber(parseFloat("")); //false isNumber(parseFloat("Infinity")); //false isNumber(parseFloat("12px")); //true !}
This function determines whether the specified value is of type Number, and whether it is one of the special values Infinity, -Infinity, and NaN. If so, then this function returns true.
3.Using the ECMAScript 6 Number.isInteger (value) method. This method allows you to determine if the specified value is an integer.
Number.isInteger ("20"); // false, because this method does not translate the string to the number Number.isInteger (20); // true, because the given value is a number
Even and odd numbers
You can check whether a number is even or odd using the following functions:
// Function for checking the number for evenness function isEven (n) (return n% 2 == 0;) // Function for checking the number for oddness function isOdd (n) (return Math.abs (n% 2) == 1; )
But before carrying out such a check, it is advisable to make sure that the specified value is a number:
Value = 20; if (Number.isInteger (value)) (if (isEven (value)) (console.log ("Number" + value.toString () + "- even");))
Javascript primes
Let's consider an example in which we display primes from 2 to 100 using Javascript.
// A function that checks if the number is prime function isPrime (value) (if (isNaN (value) ||! IsFinite (value) || value% 1 || value< 2) return false; var max=Math.floor(Math.sqrt(value)); for (var i = 2; i< = max; i++) { if (value%i==0) { return false; } } return true; } // создать массив, который будет содержать простые числа от 2 до 100 var primaryNumber = ; for (var i = 2; i <= 100; i++) { if(isPrime(i)) primaryNumber.push(i); } // вывести в консоль простые числа от 2 до 100 console.log(primaryNumber);
Rounding a number in Javascript
There are various ways to round a fractional number to an integer value in JavaScript.
1. Using specially designed methods Math.floor, Math.ceil and Math.round. The Math.floor method rounds the fractional number down to the nearest integer, i.e. simply discards the fractional part. Math.ceil rounds a fractional number up to the nearest integer. Math.round rounds a number up or down depending on the value of the fractional part. If the fractional part is greater than or equal to 0.5, then up, otherwise the curl is down.
Console.log (Math.floor (7.9)); // 7 console.log (Math.ceil (7.2)); // 8 console.log (Math.round (7.5)); //eight
2. Using the toFixed method (precision). This method rounds the fractional part of a number to the specified precision. The rounding result is returned as a string.
Console.log (7.987.toFixed (2)); //"7.99 "
If there are not enough decimal places to form the specified precision of the number, then it is padded with zeros.
Console.log (7.987.toFixed (5)); //"7.98700 "
3. Through the toPrecision method. This method represents a number with the specified precision. At the same time, he can round off not only the fractional, but also the whole part of the number. This method can represent the resulting number, depending on the result, with a fixed point or in exponential form.
Console.log ((1001) .toPrecision (2)); //"1.0e+3 "console.log ((1001) .toPrecision (5)); //"1001.0 "console.log ((12.4) .toPrecision (1)); // "1e + 1" console.log ((12.4) .toPrecision (2)); // "12" console.log ((12.4) .toPrecision (3)); //"12.4 "console.log ((12.4) .toPrecision (5)); //"12.400 "
4. Using logical operators NOT or OR.
// via double logical negation console.log (~~ 7.9); // 7 // by using a logical OR with zero: console.log (7.9 ^ 0); // 7
Integer and fractional part of a number
You can get the integer part of a number using the Math.floor () method and parseInt ():
Console.log (Math.floor (7.21)); // 7 console.log (parseInt (7.21)); // 7
You can get the fractional part of a number using the percentage (%) operator. This operator returns the remainder that will be obtained by dividing the first number by the second. In this case, 1 must be used as the 2 number.
Console.log (7.21% 1); // 0.20999999999999996 // accurate to 2 decimal places console.log ((7.21% 1) .toFixed (2)); // "0.21"
In addition, the fractional part can also be obtained using calculations:
Var number = 7.21; var fractionNumber = number - Math.floor (Math.abs (number)); console.log (fractionNumber); // 0.20999999999999996
Is the number even divisible
You can determine whether a number is evenly divisible using the percent operator:
Var number = 9; // if the remainder of dividing number by 3 is 0, then yes, otherwise no if (number% 3 == 0) (console.log ("Number" + number + "is divisible by 3");) else (console. log ("Number" + number + "is not divisible by 3");)
Formatting numbers
In JavaScript, the toLocaleString () method allows you to format the output of a number to match the regional (operating system) language settings.
For example, let's format the number according to the regional standards that are installed on the system by default:
Var number = 345.46; console.log (number.toLocaleString ()); // "345.46"
For example, let's format the number in accordance with the regional standards of Russia (ru):
Console.log ((108.1) .toLocaleString ("ru-RU")); // "108,1"
This method can also be used to format a number as a currency:
Console.log ((2540.125) .toLocaleString ("ru-RU", (style: "currency", currency: "RUB"))); // "2 540.13 ₽" console.log ((89.3) .toLocaleString ("ru-RU", (style: "currency", currency: "USD"))); // "89.30 $" console.log ((2301.99) .toLocaleString ("ru-RU", (style: "currency", currency: "EUR"))); // "€ 2,301.99"
Representation of a number as a percentage:
Console.log ((0.45) .toLocaleString ("ru-RU", (style: "percent"))); // "45%"
Split the number into digits (useGrouping property):
Console.log ((125452.32) .toLocaleString ("ru-RU", (useGrouping: true))); // "125 452.32"
Print a number with a certain number of digits (2) after the decimal point:
Console.log ((1240.4564) .toLocaleString ("ru-RU", (minimumFractionDigits: 2, maximumFractionDigits: 2))); // "1 240.46"
Comparing numbers
JavaScript uses the following operators to compare numbers: == (equal),! = (Not equal),> (greater than),< (меньше), >= (greater than or equal),<= (меньше или равно).
For example, let's compare two numbers:
Console.log (2> 3); // false console.log (5> = 3); // true
When comparing numbers with fractional parts, it is necessary to take into account the errors that may arise during these calculations.
For example, in JavaScript, the sum of numbers (0.2 + 0.4) is not 0.6:
Console.log ((0.2 + 0.4) == 0.6); // false
Errors occur because all calculations are computer or other electronic device produces in 2 number system. Those. before performing any actions, the computer must first convert the numbers represented in the expression into 2 number system. But, not any fractional decimal number can be represented in 2 number system exactly.
For example, the number 0.25 10 is converted exactly to the binary system.
0.125 × 2 = 0.25 | 0 0.25 × 2 = 0.5 | 0 0.5 × 2 = 1 | 1 0.125 10 = 0.001 2
For example, the number 0.2 10 can be converted to a 2 system only with a certain precision:
0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 0.2 × 2 = 0.4 | 0 0.4 × 2 = 0.8 | 0 0.8 × 2 = 1.6 | 1 0.6 × 2 = 1.2 | 1 ... 0.2 10 = 0.001100110011 ... 2
As a result, these errors will affect the calculation of the sum of the two numbers and the comparison results. Those. it turns out that in fact JavaScript will see this record as follows:
0.6000000000000001==0.6
When calculating or displaying numbers with a fractional part, you must always indicate the precision with which it must be done.
For example, compare numbers up to 2 decimal places using the toFixed () and toPrecision () methods:
// method toFixed () console.log ((0.2 + 0.4) .toFixed (2) == (0.6) .toFixed (2)); // true // method toPrecision () console.log ((0.2 + 0.4) .toPrecision (2) == (0.6) .toPrecision (2)); // true
Basic math operations
The following mathematical operators exist in JavaScript: + (addition), - (subtraction), * (multiplication), / (division),% (modulo), ++ (increase value by 1), - (decrease value by 1 ).
6 + 3 // 9 6-3 // 3 6 * 3 // 18 6/3 // 2 6% 3 // 0, i.e. 6: 3 = 2 => 6-3 * 2 => rest (0) 5% 2 // 1, i.e. 5: 2 = 2 (.5) => 5-2 * 2 => rest (1) 7.3% 2 //1.3, i.e. 7.3: 2 = 3 (.65) => 7.3-2 * 3 => rest (1.3) // the sign of the result of the% operation is equal to the sign of the first value -9% 2.5 //-1.5, i.e. 9: 2.5 = 3 (.6) => 9-2.5 * 3 => rest (1.5) -9% -2.5 //-1.5, i.e. 9: 2.5 = 3 (.6) => 9-2.5 * 3 => rest (1.5) -2% 5 // - 2, i.e. 2: 5 = 0 (.4) => 2-5 * 0 => rest (2) x = 3; console.log (x ++); // prints 3, y sets 4 later console.log (x); // 4 x = 3; console.log (++ x); // sets 4 and prints x = 5; console.log (x--); // prints 5, y sets 4 later console.log (x); // 4 x = 5; console.log (- x); // sets 4 and outputs In addition, JavaScript has combined operators: x + = y (x = x + y), x- = y (x = xy), x * = y (x = x * y), x / = y (x = x / y), x% = y (x = x% y). x = 3; y = 6; x + = y; console.log (x); // 9 x = 3; y = 6; x- = y; console.log (x); // - 3 x = 3; y = 6; x * = y; console.log (x); // 18 x = 3; y = 6; x / = y; console.log (x); //0.5 x = 3; y = 6; x% = y; console.log (x); // 3
