JavaScript - tutorial - 11 - data types

                    const max = 2n ** (64n - 1n) - 1n;
                    function check64bit(number) {
                    (number > max) ?
                        console.log('Number doesn\'t fit in signed 64-bit integer!') :
                        console.log(BigInt.asIntN(64, number));
                    }
                    check64bit(2n ** 64n);
                    // expected output: "Number doesn't fit in signed 64-bit integer!"
                    check64bit(2n ** 32n);
                    // expected output: 4294967296n
                

                    const max = 2n ** 64n - 1n;
                    function check64bit(number) {
                    (number > max) ?
                        console.log('Number doesn\'t fit in unsigned 64-bit integer!') :
                        console.log(BigInt.asUintN(64, number));
                    }
                    check64bit(2n ** 64n);
                    // expected output: "Number doesn't fit in unsigned 64-bit integer!"
                        check64bit(2n ** 32n);
                    // expected output: 4294967296n
                

                    const bigint = 123456789123456789n;
                    // German uses period for thousands
                    console.log(bigint.toLocaleString('de-DE'));
                    // expected output: "123.456.789.123.456.789"
                    // request a currency format
                    console.log(bigint.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));
                    // expected output: "123.456.789.123.456.789,00 €"
                

                    console.log(1024n.toString());
                    // expected output: "1024"
                    console.log(1024n.toString(2));
                    // expected output: "10000000000"
                    console.log(1024n.toString(16));
                    // expected output: "400"
                

                    console.log(typeof Object(1n));
                    // expected output: "object"
                    console.log(typeof Object(1n).valueOf());
                    // expected output: "bigint"
                

                    const flag = new Boolean();
                    console.log(flag);
                    // expected output: false
                

                    const flag1 = new Boolean(true);
                    console.log(flag1.toString());
                    // expected output: "true"
                    const flag2 = new Boolean(1);
                    console.log(flag2.toString());
                    // expected output: "true"
                

                    const x = new Boolean();
                    console.log(x.valueOf());
                    // expected output: false
                    const y = new Boolean('Mozilla');
                    console.log(y.valueOf());
                    // expected output: true
                

                const result = Math.abs(0.2 - 0.3 + 0.1);
                console.log(result);
                // expected output: 2.7755575615628914e-17
                console.log(result < Number.EPSILON);
                // expected output: true
            

                console.log(Number.isFinite(1 / 0));
                // expected output: false
                console.log(Number.isFinite(10 / 5));
                // expected output: true
                console.log(Number.isFinite(0 / 0));
                // expected output: false
            

                function fits(x, y) {
                    if (Number.isInteger(y / x)) {
                    return 'Fits!';
                    }
                    return 'Does NOT fit!';
                }
                console.log(fits(5, 10));
                // expected output: "Fits!"
                console.log(fits(5, 11));
                // expected output: "Does NOT fit!"
            

                function typeOfNaN(x) {
                    if (Number.isNaN(x)) {
                    return 'Number NaN';
                    }
                    if (isNaN(x)) {
                    return 'NaN';
                    }
                }
                console.log(typeOfNaN('100F'));
                // expected output: "NaN"
                console.log(typeOfNaN(NaN));
                // expected output: "Number NaN"
            

                function warn(x) {
                    if (Number.isSafeInteger(x)) {
                    return 'Precision safe.';
                    }
                    return 'Precision may be lost!';
                }
                console.log(warn(Math.pow(2, 53)));
                // expected output: "Precision may be lost!"
                console.log(warn(Math.pow(2, 53) - 1));
                // expected output: "Precision safe."
            

                const x = Number.MAX_SAFE_INTEGER + 1;
                const y = Number.MAX_SAFE_INTEGER + 2;
                console.log(Number.MAX_SAFE_INTEGER);
                // expected output: 9007199254740991
                console.log(x);
                // expected output: 9007199254740992
                console.log(x === y);
                // expected output: true
            

                function multiply(x, y) {
                    if (x * y > Number.MAX_VALUE) {
                    return ('Process as Infinity');
                    }
                    return (x * y);
                }
                console.log(multiply(1.7976931348623157e+308, 1));
                // expected output: 1.7976931348623157e+308
                console.log(multiply(1.7976931348623157e+308, 2));
                // expected output: "Process as Infinity"
            

                const x = Number.MIN_SAFE_INTEGER - 1;
                const y = Number.MIN_SAFE_INTEGER - 2;
                console.log(Number.MIN_SAFE_INTEGER);
                // expected output: -9007199254740991
                console.log(x);
                // expected output: -9007199254740992
                console.log(x === y);
                // expected output: true
            

                function multiply(x, y) {
                    if (x * y < Number.MIN_VALUE) {
                    return 'Process as -Infinity';
                    }
                    return (x * y);
                }
                console.log(multiply(5e-324, 1));
                // expected output: 5e-324
                console.log(multiply(-1.7976931348623157e+308, 2));
                // expected output: Process as -Infinity
            

                function clean(x) {
                    if (x === Number.NaN) {
                    // can never be true
                    return null;
                    }
                    if (isNaN(x)) {
                    return 0;
                    }
                }
                console.log(clean(Number.NaN));
                // expected output: 0
            

                function checkNumber(smallNumber) {
                    if (smallNumber === Number.NEGATIVE_INFINITY) {
                    return 'Process number as -Infinity';
                    }
                    return smallNumber;
                }
                console.log(checkNumber(-Number.MAX_VALUE));
                // expected output: -1.7976931348623157e+308
                console.log(checkNumber(-Number.MAX_VALUE * 2));
            // expected output: "Process number as -Infinity"
            

                function circumference(r) {
                    if (Number.isNaN(Number.parseFloat(r))) {
                    return 0;
                    }
                    return parseFloat(r) * 2.0 * Math.PI ;
                }
                console.log(circumference('4.567abcdefgh'));
                // expected output: 28.695307297889173
                console.log(circumference('abcdefgh'));
                // expected output: 0
            

                function roughScale(x, base) {
                    const parsed = Number.parseInt(x, base);
                    if (Number.isNaN(parsed)) {
                    return 0;
                    }
                    return parsed * 100;
                }
                console.log(roughScale(' 0xF', 16));
                // expected output: 1500
                console.log(roughScale('321', 2));
                // expected output: 0
            

                function checkNumber(bigNumber) {
                    if (bigNumber === Number.POSITIVE_INFINITY) {
                    return 'Process number as Infinity';
                    }
                    return bigNumber;
                }
                console.log(checkNumber(Number.MAX_VALUE));
                // expected output: 1.7976931348623157e+308
                console.log(checkNumber(Number.MAX_VALUE * 2));
                // expected output: Process number as Infinity
            

                function expo(x, f) {
                    return Number.parseFloat(x).toExponential(f);
                }
                console.log(expo(123456, 2));
                // expected output: "1.23e+5"
                console.log(expo('123456'));
                // expected output: "1.23456e+5"
                console.log(expo('oink'));
                // expected output: "NaN"
            

                function financial(x) {
                    return Number.parseFloat(x).toFixed(2);
                }
                console.log(financial(123.456));
                // expected output: "123.46"
                console.log(financial(0.004));
                // expected output: "0.00"
                console.log(financial('1.23e+5'));
                // expected output: "123000.00"
            

                function eArabic(x){
                    return x.toLocaleString('ar-EG');
                }
                console.log(eArabic(123456.789));
                // expected output: "١٢٣٬٤٥٦٫٧٨٩"
                console.log(eArabic('123456.789'));
                // expected output: "123456.789"
                console.log(eArabic(NaN));
                // expected output: "ليس رقم"
            

                function precise(x) {
                    return Number.parseFloat(x).toPrecision(4);
                }
                console.log(precise(123.456));
                // expected output: "123.5"
                console.log(precise(0.004));
                // expected output: "0.004000"
                console.log(precise('1.23e+5'));
                // expected output: "1.230e+5"
            

                function hexColour(c) {
                    if (c < 256) {
                    return Math.abs(c).toString(16);
                    }
                    return 0;
                }
                console.log(hexColour(233));
                // expected output: "e9"
                console.log(hexColour('11'));
                // expected output: "b"
            

                const numObj = new Number(42);
                console.log(typeof numObj);
                // expected output: "object"
                const num = numObj.valueOf();
                console.log(num);
                // expected output: 42
                console.log(typeof num);
                // expected output: "number"
            

                    // no error
                    let message = "hello";
                    message = 123456;
                
                

                    let n = 123;
                    n = 12.345;
                    
                    alert( 1 / 0 ); // Infinity

                    alert( Infinity ); // Infinity

                    alert( "not a number" / 2 ); // NaN, such division is erroneous

                    alert( NaN + 1 ); // NaN
                    alert( 3 * NaN ); // NaN
                    alert( "not a number" / 2 - 1 ); // NaN
                

                    // the "n" at the end means it's a BigInt
                    const bigInt = 1234567890123456789012345678901234567890n;
                

                    let str = "Hello";
                    let str2 = 'Single quotes are ok too';
                    let phrase = `can embed another ${str}`;

                    let name = "John";
                    // embed a variable
                    alert( `Hello, ${name}!` ); // Hello, John!
                    // embed an expression
                    alert( `the result is ${1 + 2}` ); // the result is 3
                

                    let nameFieldChecked = true; // yes, name field is checked
                    let ageFieldChecked = false; // no, age field is not checked

                    let isGreater = 4 > 1;
                    alert( isGreater ); // true (the comparison result is "yes")
                

                    let age = null;
                

                    let age;
                    alert(age); // shows "undefined"
                    
                    let age = 100;
                    // change the value to undefined
                    age = undefined;
                    alert(age); // "undefined"
                

                    typeof undefined // "undefined"
                    typeof 0 // "number"
                    typeof 10n // "bigint"
                    typeof true // "boolean"
                    typeof "foo" // "string"
                    typeof Symbol("id") // "symbol"
                    typeof Math // "object"  (1)
                    typeof null // "object"  (2)
                    typeof alert // "function"  (3)