THE TYPE NUMBER AND OTHER PRIMITIVE DATA IN JAVASCRIPT

NUMBERS IN JAVASCRIPT

Number with the ES2019 specification is the only type associated with numbers. We do not have the float type for decimal numbers. Numbers in javascript are represented according to the IEEE 754 floating point 64-bit standard. Every number even integers are represented and stored in memory as 64-bit floating point numbers.

THE SCIENTIFIC OR EXPONENTIAL NOTATION

Any number can be represented with scientific notation (also called exponential):

mantissa*base ^exponent

The mantissa are the significant figures, excluding zero; the base is ten because we are in the decimal system. For example, a number we can represent it as (figure below):

We see that the comma fluctuates, as the exponent increases it moves from right to left, while as the exponent decreases it moves from left to right.

Let’s take one more example.

The normalized scientific form requires that there be a number before the root point that is not zero. The floating point standard for storing numbers transforms them into the normalized scientific notation.

THE IEEE 754 STANDARD

If the sign bit is zero then the number is positive, otherwise negative. As much as 52 bits is a lot to represent the mantissa,
there are cases where they may not be enough, and it is not just a problem for large numbers.

Let’s start by saying that this is not a problem with javascript but with the IEEE 754 standard. 0.1₁₀is a periodic binary number that repeats infinitely, so it must be rounded, kind of like we do with decimal numbers .

As small as the difference is, effectively we cannot say that the two numbers are the same. Problems occur with very large or very small numbers. With this system we can represent exactly the numbers in the range -(2⁵³-1) and + (2⁵³-1).

Copy to Clipboard

<!DOCTYPE html>
<html lang="it">
<head>
    <meta charset="UTF-8">
    <title>Numeri in Javascript</title>
    <script type="rocketlazyloadscript">
        //OPERAZIONI CON I NUMERI
        function operazioni()
        {
            let ris = 10 + 3 * 2;
            console.log(ris);
            /*--Se vogliamo cambiare la precedenza tra gli operatori
            mettiamo le parentesi.*/
            ris = (10 + 3) * 2;
            console.log(ris);
            /*--L'operatore modulo % restituisce il resto della
            divisione tra due numeri.*/
            let mod = 10 % 3;
            console.log(mod);
            /*--Elevamento a potenza**   */
            let potenza = 2 ** 3;
            console.log(potenza);
            /*Post incremento */
            let num = 0;
            console.log(num++);//0 il post incremento prima restituisce il numero
            //poi lo incrementa
            /*--Pre incremento*/
            let num2 = 0;
            console.log(++num2);//1 Prima viene incrementato il valore poi restituito.
            /*--Stesso discorso vale per il post decremento e pre decremento*/
            /*--Un numero può anche essere definito istanziando un oggetto Number.*/
            let num3 = new Number(110);
            console.log(Number);/*Restituisce proprietà costanti e metodi (funzioni)*/
            let numeroGrande = Number.MAX_SAFE_INTEGER + 10;
            //MAX_SAFE_INTEGER numero più grande rappresentabile sicuro.
            console.log(Number.isSafeInteger(numeroGrande))//False
            console.log(Math);
            console.log(Math.random()*1000);//Numero compreso tra 0 e 1000
            let casuale = Math.random() * 1000;
            casuale = Math.trunc(casuale);
            console.log(casuale);

}
    </script>
</head>
<body onload="operazioni();">
   <script type="rocketlazyloadscript">
     function one()
     {
        let a = 10;
        let b = 3.4;
        console.log(typeof a);
        console.log(typeof b);
        /*Il tipo è sempre number sia per i numeri interi sia per quelli floating point;*/
     }
     one();
     function fix_01_piu_02()
     {
        /*L'oggetto Number contiene una proprietà prototype 
        i cui metodi e proprietà possono essere invocati sui
        tipi primitivi. Il metodo che ci interessa è toFixed() 
        che rstituisce una stringa e ci permette di stabilire quante 
        cifre decimali dopo la virgola devono essere rappresentate.
        L'operatore unario + serve a convertire la stringa in numero.*/
        console.log(+(0.499.toFixed(1)));//0.5
        console.log(+(0.1 + 0.2).toFixed(10));
        //SOLUZIONE
        let risultato = (+(0.1 + 0.2).toFixed(10)) == (+(0.3.toFixed(10)));
        console.log('Il risultato di 0.1 + 0.2 == 0.3 è: '+risultato);
     }
     fix_01_piu_02();
   </script> 
</body>
</html>

THE BIGINT TYPE.

The BigInt type represents integers. We can do all the arithmetic operations we want, it can also represent very large numbers that go far beyond the constant MAX_SAFE_INTEGER thus exceeding the limits of type Number.

Copy to Clipboard

TYPE BOOLEAN

Boolean represents a logical entity and can have two values: true and false. For example, in JavaScript, Boolean conditional tests are often used to decide which sections of code to execute (such as if statements) or repeat (such as for loops).

NULL VS UNDEFINED

Null means no value, undefined indicates that a variable, object or function has been declared but not defined. Using the operator !! both return false, plus both are primitive data.

Copy to Clipboard

<!DOCTYPE html>
<html lang="it">
<head>
    <meta charset="UTF-8">
    <title>I Boolean</title>
</head>
<body>
    <script type="rocketlazyloadscript">
        /*--Valori considerati false in javascript:
        false, '' , Nan, null, undefined, 0, -0.
        Tutti gli altri valori sono considerati veri.*/
        let isDeveloper = true;

if(isDeveloper){
            console.log('developer');
        }else{
            console.log('Non è un developer');
        }
        /*--Nella maggior parte dei casi un valore booleano
        sarà il risultato di un'espressione.*/
        if(4 < 3){    //false
            console.log('4 minore di 3');
        }else{
            console.log('4 maggiore di 3');
        }
        let str1 = 'ciao';
        let str2 = 'Ciao';
        if(str1 == str2){
            console.log('str1 è uguale a str2');
        }else{
            console.log('No perchè JS è case sensitive');
        }
        let a = 10, b = 0, c = 'ciao';
        if(a){//true
            console.log('vero');
        }else{
            console.log('falso');
        }
        if(b){//false
            console.log('vero');
        }else{
            console.log('falso');
        }
        if(c){//true
            console.log('vero');
        }else{
            console.log('falso');
        }
        /*--in JS abbiamo un operatore che ci consente di trasformare
        il suo corrispettivo in booleano.E' il doppio punto escalamito.*/
        console.log(!!'ciao');//true
        console.log(!!0);//false
    </script>
</body>
</html>

Copy to Clipboard

LINKS TO PREVIOUS POSTS

THE JAVASCRIPT LANGUAGE

LINK TO CODE ON GITHUB

GITHUB