DEV Community: Kaushal

Bring Linux environment to Windows

Kaushal — Mon, 14 Feb 2022 16:37:50 +0000

Hey there.
When a project is built up for a specific environment and you can't execute it in another, it's a nightmare for a developer. For example, the majority of the projects are configured to run on a Linux environment. As a result, setting up VirtualBox on a Windows machine for Linux is a simple option (Ubuntu). However, this is incredibly slow because it has access to a limited quantity of primary memory, which can hinder our performance.

I discovered a Windows feature, which is an excellent method for running a Linux environment on Windows, WSL(Windows Subsystem for Linux) is a feature provided by Windows.

The steps to do so are outlined below.

Search for Turn Windows features on or off in your Windows machine, which gives you a screen something like this.
Click on the checkbox called Windows Subsystem for Linux and press OK. This will restart your computer so that WSL can be installed. There is another way to do it, that uses the command line, but this one is easiest.
Install Ubuntu from the Microsoft store so WSL can assess the subsystem(it require an environment to run the WSL). I would recommend the latest version of Ubuntu(20.04), which you can install from this link.
After the Ubuntu installation is complete, please open it and complete the basic setup process, such as setting up a username and password. At the end of the process you will see a screen like below. Close the Ubuntu window.
There are multiple ways of accessing the linux subsystem from terminal but I like using it with Windows Terminals download link for Windows Terminals from the Microsoft Store.
By default, when you open Windows Terminal after installation, it will launch Windows PowerShell. By clicking the chevron symbol, you may see all of the available terminals on your system.
Choose the third option to open unbuntu terminal.
If you run the command ls, you will see your Windows files and folders from the Ubuntu terminal and can access them. In my case,

Hurry, we set up the WSL successfully!

WSL includes several ridiculous features:

If your local server is running on Ubuntu, you can access it from localhost; you can browse the React.js project from localhost even though the server is running on Ubuntu terminal vice versa, for example. Similarly, If you have a database server(MongoDB, MySQL, etc.) running on Windows, your backend server can access that DB server from the Ubuntu environment.

A tip to open your Vistual Studio Code using Ubuntu host. Install Remote - WSL extention on your VS Code.
Now, navigate to the directory you wish to access in VS Code and type the command 'code .' if you run this program for the first time on Ubuntu, it will install a few packages that allow you to open VS Code.

Number in JavaScript

Kaushal — Fri, 17 Jul 2020 14:46:24 +0000

Introduction

Number is a primitive wrapper object used to represent and manipulate numbers like 12 or -3.34.
The Number constructor contains constants and methods which are useful for working numbers.
Number() function is used for converting any other type of value into numbers.
JavaScript Number type is a double-precision 64-bit binary format IEEE 754 value.
JavaScript Number can represent fractional values. But, with limitations. It can only keep about 17 decimal places of precision.
A number literal like 12 in JavaScript code is still floating-point value, not an integer. JavaScript has now BigInt type, but it was not designed to replace the Number but for safely store and operate on large integer even beyond the safe integer limit for Number.
When you use as a function, Number(value) converts a string or any other value to the Number type. If the value can't be converted, it returns NaN.

Constructor in Number

Using Number() you can create a new Number value.

Static properties of Number

`Number.EPSILON`

The smallest interval between two representable numbers.
It uses to represent the difference between 1 and the smallest floating-point number greater than 1.
It return the smallest positive number approaching zero.

`Number.MAX_SAFE_INTEGER`

The maximum safe integer in JavaScript (2⁵³ - 1).

`Number.MAX_VALUE`

The largest positive representable number.

`Number.MIN_SAFE_INTEGER`

The minimum safe integer in JavaScript (-(2⁵³ - 1)).

`Number.MIN_VALUE`

The smallest positive representable number—that is, the positive number closest to zero (without actually being zero).

`Number.NaN`

Special "Not a Number" value.

`Number.NEGATIVE_INFINITY`

Special value representing negative infinity. Returned on overflow.

`Number.POSITIVE_INFINITY`

Special value representing infinity. Returned on overflow.

`Number.prototype`

Allows the addition of properties to the Number object.

Example

Number.EPSILON           // 2.220446049250313e-16
Number.MAX_SAFE_INTEGER  // 9007199254740991
Number.MAX_VALUE         // 1.7976931348623157e+308
Number.MIN_SAFE_INTEGER  // -9007199254740991
Number.MIN_VALUE         // 5e-324
Number.NaN               // NaN
Number.NEGATIVE_INFINITY // -Infinity
Number.POSITIVE_INFINITY // Infinity
Number.prototype         // Number {...}

Static methods of Number

`Number.isNaN()`

Determine whether the passed value is NaN.

`Number.isFinite()`

Determine whether the passed value is a finite number.

`Number.isInteger()`

Determine whether the passed value is an integer.

`Number.isSafeInteger()`

Determine whether the passed value is a safe integer (number between -(2⁵³ - 1) and (2⁵³ - 1)).

`Number.parseFloat(string)`

This is the same as the global parseFloat() function.

`Number.parseInt(string, [radix])`

This is the same as the global parseInt() function.

Example

Number.isNaN(NaN)         // true
Number.isFinite(12)       // true
Number.isInteger(-32)     // true
Number.isSafeInteger(23)  // true
Number.parseFloat('50')   // 50
Number.parseInt('string') // NaN

Instance methods of Number

`Number.prototype.toExponential(fractionDigits)`

Returns a string representing the number in exponential notation.
toExponential() argument must be between 0 and 100.

`Number.prototype.toFixed(digits)`

Returns a string representing the number in fixed-point notation.
toFixed() argument must be between 0 and 100.

`Number.prototype.toLocaleString([locales [, options]])`

Returns a string with a language sensitive representation of this number. Overrides the Object.prototype.toLocaleString() method.

`Number.prototype.toPrecision(precision)`

Returns a string representing the number to a specified precision in fixed-point or exponential notation.
toPrecision() argument must be between 0 and 100.

`Number.prototype.toString([radix])`

Returns a string representing the specified object in the specified radix ("base"). Overrides the Object.prototype.toString() method.
toString() radix argument must be between 2 and 36.

`Number.prototype.valueOf()`

Returns the primitive value of the specified object. Overrides the Object.prototype.valueOf() method.

Example

var x = 10;
x.toExponential(4) // 1.0000e+1
x.toFixed(2)       // 10.00
x.toLocaleString() // 10
x.toPrecision(7)   // 10.00000
x.toString(2)      // 1010
x.valueOf()        // 10

Summary

Number(new Date('January 03, 2005 04:34:56'))   // 1104707096000
Number('123')                                   // 123
Number('12.3')                                  // 12.3
Number('12.00')                                 // 12
Number('123e-1')                                // 12.3
Number('')                                      // 0
Number(null)                                    // 0
Number('0x11')                                  // 17
Number('0b11')                                  // 3
Number('0o11')                                  // 9
Number('foo')                                   // NaN
Number('100a')                                  // NaN
Number('-Infinity')                             //-Infinity

JavaScript data-types

Kaushal — Tue, 30 Jun 2020 14:47:05 +0000

Introduction

Inside the computer’s world, there is only data which define in bits.
All this data is stored as long sequences of bits and is thus fundamentally alike.
Bits are any kind of two-valued things, usually described as zeros and ones.

For example, we can express the number 13 in bits. It works the same way as a decimal number, but instead of 10 different digits, you have only 2, and the weight of each increases by a factor of 2 from right to left. Here are the bits that make up the number 13, with the weights of the digits shown below them:

128 64 32 16 8 4 2 1
  0  0  0  0 1 1 0 1

So that’s the binary number 00001101. Its non-zero digits stand for 8, 4, and 1, and add up to 13.

Dynamic typing

JavaScript is a loosely typed and dynamic language.
Variables in JavaScript are not directly associated with any particular value type, and any variable can be assigned (and re-assigned) values of all types:

let foo = 42;    // foo is a number
foo     = 'bar'; // foo is now a string
foo     = true;  // foo is now a boolean

primitive (or primary): These types are called “primitive” because their values can contain only a single thing (be it a string or a number or whatever).
- String
- Number
- BigInt
- Boolean
- Undefined
- Null
composite (or reference)
- Object
- Function

Primitive

String, Number, and Boolean are primitive data types.

String

JavaScript's String type is used to represent textual data. It is a set of "elements" of 16-bit unsigned integer values. Each element in the String occupies a position in the String. The first element is at index 0, the next at index 1, and so on. The length of a String is the number of elements in it.
We can use single quotes, double quotes, or backticks to mark strings, as long as the quotes at the start and the end of the string match.
For instance,

var a = "Welcome to Devkode";
var b = 'LEARN | DEVELOP | DEPLOY';
var c = `KEEP LEARNING KEEP SHARING`;

console.log(a); // Welcome to Devkode
console.log(b); // LEARN | DEVELOP | DEPLOY
console.log(c); // KEEP LEARNING KEEP SHARING

Unlike C language JavaScript's strings are immutable. This means a string created, it is not possible to modify it.

Number

JavaScript automatically takes data-type on what value are you assigning.
For instance,

var a = 10;
console.log(a) // 10

JavaScript store value between -(2⁵³ − 1) and 2⁵³ − 1).
The number typehas three symbolic value +Infinity, -Infinity, and NaN ("Not a Number").
We can also check minmum value and maximum value within ±Infinity.

console.log(Number.MAX_VALUE); // 1.7976931348623157e+308
console.log(Number.MIN_VALUE); // 5e-324

In ECMAScript2015, we can albe to check the number is in the double-precision floating-point number range using Number.isSafeInteger(). We can get the rang of SafeInteger using Number.MAX_SAFE_INTEGER and Number.MIN_SAFE_INTEGER. Beyond this range, interget is not safe in JavaScript

BigInt

The BigInt type is a numeric primitive in JavaScript that can represent integers with arbitrary precision.
For assign BigInt value to variable, we have to use n character followed by integer value.

var a = 5n;
console.log(a); // 5n

With the BigInt, we can store a value beyond the safe number limit for Number.
BigInt is not strictly equal to a Number, but it is loosely so.

Boolean

It is often useful to have a value that distinguishes between only two possibilities, like yes and no or on and off.
Boolean has just two values, true and false, which are writtern as word.

var a = false;
var b = true;
console.log(a) // false
console.log(b) // true

Null

The special null value does not belong to any of the types described above.
In JavaScript, null is not a “reference to a non-existing object” or a “null pointer” like in some other languages.

var a = null;
console.log(a) // null

Undefined

The special value undefined also stands apart. It makes a type of its own, just like null.
The meaning of undefined is “value is not assigned” to specified variable.

var a;
console.log(a); // undefined

Composite

Object, Array, and Function (which are all types of objects) are composite data types.

Object

Objects allow us to group values—including other objects—to build more complex structures.
Objects are used to store collections of data and more complex entities.
An object comes with a pair of keys and values.

var a = { name: 'value' };
console.log(a); // {name: "value"}

We can also create an object instance with the help of a new keyword. This way we can create an object instance of a class

var str = new String();
var bool = new Boolean();
var num = new Number();

Function

Functions are regular objects with the additional capability of being callable.

console.log(console.log) // ƒ log() { [native code] }

Special

Symbols are new to JavaScript in ECMAScript 2015.
A Symbol is a unique and immutable primitive value and may be used as the key of an Object property.
In some programming languages, Symbols are called "atoms".

Summary

The typeof operator returns the type of the argument. It’s useful when we want to process values of different types differently or just want to do a quick check.

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

number for any kind of numbers of any kind: integer or floating-point, integers are limited by ±253.
bigint is for integer numbers of arbitrary length.
string for strings. A string may have zero or more characters.
boolean for true/false.
null for unknown values.
undefined for unassigned values.
object for more complex data structures.
symbol for unique identifiers.

this keyword in JavaScript

Kaushal — Sun, 28 Jun 2020 18:24:39 +0000

Introduction

A function's this behave is a little bit different in JavaScript, unlike other languages.
it also work diffrently with the use of strict mode and non-strict mode.

In non-strict both functions calls' this point to window/object and return true.

this in function context.

this and object conversion

with `bind` method

this work differently in both Arrow and Normal function

Difference between Arrow and Normal functions.

Kaushal — Sun, 28 Jun 2020 14:12:32 +0000

Arrow function

The arrow functions are work same as with normal functions. It was introduce in ES6.
Syntax const variable = () => {}
Ex
var foo = _ => 'Hii';
It's same as
function name(params) {
return 'Hii';
}
These arrow functions are make eassy our work and readablity.
Normal function
- var foo = function(name) { return function(age) { return function(city) { return ${name} ${age} ${city} } }
}
Arrow function
- var foo = (name) => (age) => (city) => ${name} ${age} ${city};

Difference between normal and arrow functions.

    var name = "Mike";
    var obj = {
        name: "Tom",
        foo: function() {
            console.log(this);
            var bar1 = function() {
                console.log(this.name); // Point to Window(Parent)
            }
            var bar2 = () => {
                console.log(this.name); // Point to current Object
            }
            bar1();
            bar2();
        }
    }
    obj.foo();
    // If we not use var it point to parent
    var bar = () => {
        var x= "sad";
        let y= "sasa";
        console.log(this.x); // Window // undefined
        console.log(this.y); // sasa
    }
    bar();

Why we need Arrow function.

Arrow functions cannot called with Constructer.
Arrow functions are not having their own this. So, we cannot update using this.
- Whenever we use this inside the arrow function it will check parent, until not find parent.
- Arrow alway have lasical scope.

When use it.

Use arrow function only when you have to use parent's this.
Use only when we need it, according to requirenment.

Not use.

It has not thier own this so we can not call it as a Constructor

Node.js

Kaushal — Mon, 15 Jun 2020 14:19:28 +0000

Core things in Node.js

proceses object

In the process object, there is an argv property. Which gives us arguments, those we have passed via console.
```
console.log(process.argv);
```

We can pass any number of arguments as we want, and access it into the script.

var index = process.argv.indexOf("Hello");
console.log(process.argv[index]);

We can also pass arguments as a flag.

var index = process.argv.indexOf("--words") + 1;
console.log(process.argv[index]);

Write on the console using process object.

process.stdout.write("Hello");
process.stdout.write("World\n\n");

Take input from console using process object.

But in this case program execution will never stop.

We have to stop it manually.

process.stdin.on("data", (data) => {
process.stdout.write(data);
});

In below example stop manually process.

process.stdin.on("data", (data) => {
process.stdout.write(data);
process.exit(); // this function call stop the process
});

Handle console logging inside the script.

In this example console will clear before each and every print statement.

var index = 1;
const interval = setInterval(() => {
process.stdout.clearLine();
process.stdout.cursorTo(0);
process.stdout.write(${index++});
}, 500);
setTimeout(() => {
clearInterval(interval);
}, 3000);

util module

Util module use for logging data on the console like console.log().
- It displays data with time information.
```
const util = require("util");
util.log("Node.js process object");
```

v8 module

Showing heap data of program execution.

const v8 = require("v8");
const util = require("util");
util.log(v8.getHeapStatistics());

readline module

readline has createInterface.

We have to provide read stream and output stream in the createInterface.

const readline = require("readline");
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout,
});
rl.question("Where are you living? ", (answer) => {
rl.write(You are living in ${answer}\n);
process.exit();
});

events module

event emtier allow us to create our own Event that we can call any time we want throughout the script's execution.

const events = require("events");
const emiter = new events.EventEmitter();
emiter.on("customEvent", (message, sender) => {
console.log("Inside the CustomEvent");
console.log(${sender} sent you: ${message});
});
emiter.emit("customEvent", "Hii, there", "User");

JavaScript destructuring

Kaushal — Sat, 18 Apr 2020 03:45:54 +0000

Introduction

JavaScript ES6 comes with the destructuring assignments. A name define its use, destructure values from an array and properties from an object. For instance,

Syntax

let x, y, rest;
[x, y] = [1, 2];

console.log(a); //  1
console.log(b); //  2

[x, y, ...rest] = [1, 2, 3, 4, 5];

console.log(x); //  1
console.log(y); //  2
console.log(rest); //  [3,4,5]

({ a, b, ...c } = {a: "first", b: "second", c: "third", d: "fourth", e: "fifth"});

console.log(a); //  first
console.log(b); //  second
consoel.log(c); //  { c: 'third', d: 'fourth', e: 'fifth' }

The destructuring assignment uses syntax, on the left side of the equal sign, is assignment of the values from the sourced variable, source is on the right side of the equal sign.

Array destructuring

Assignment is allowed separate from declaration.

let a, b;

[a, b] = [1, 2];
console.log(a); // 1
console.log(b); // 2

We can relinquish(omit) the unnecessary values from the array while destructuring it.

let [x, , y, , , z] = [1, 2, 3, 4, 5, 6];
console.log(x); // 1
console.log(y); // 3
console.log(y); // 6

A single comma (,) can seek one position forward. The common can be one or more in the destructuring list as we want to skip the values.

Rest element must be last element

let [a, , ...b, c] = [1, 2, 3, 4, 5, 6];  // ___give error___
// SyntaxError: Rest element must be last element

let [a, , , ...b] = [1, 2, 3, 4, 5, 6];

console.log(a); //  1
console.log(b); // [ 4, 5, 6 ]

Always consider the rest operator as the last element while unpacking the values from source variable.

Use as a swapper

let a = 1, b = 2;

[a, b] = [b, a];
console.log(a); // 2
console.log(b); // 1

Object destructuring

Declaration and assignment

let a, b;
{ a, b } = {a: "first", b: "second"};
console.log(a); //  first
console.log(b); // second

Assigning with new name(rename)

let { a: x, b: y} = {a: "first", b: "second"};

console.log(x); //  first
console.log(y); // second

Here, it will take a and b from the object and assign it to newly named local variable x and y.

Default value

In some cases we want to pull out a value from object, only if, it's exist in it,
if not, set a default value rather than just holding an undefined in the variable.

let { a = 10, b = 20, x = 30} = {a: "first", b: "second"};

console.log(a); //  first
console.log(b); //  second
console.log(x); //  30

Default value to newly define local variable

Unpack the value from object and assigned to a variable with a different name and default value, if property not exist in the object.

let { a: xx = 10, b: yy = 20, x = 30} = {a: "first", b: "second"};

console.log(xx); //  first
console.log(yy); //  second
console.log(x); //  30

Nested object destructuring

const fruit = {
  seed: {
    countable: 'A fertilized grain, initially encased in a fruit, which may grow into a mature plant.' ,
    botany: 'A fertilized ovule, containing an embryonic plant.',
    uncountable: 'An amount of fertilized grain that cannot be readily counted.'
  },
  definition: 'All produce that contains seeds is botanically classified as a fruit.',
}

let { countable, definition } = fruit;

console.log(countable);  //  undefined
console.log(definition);  //  All produce that contains seeds is botanically classified as fruit.

See, a variable countable is printed as undefined, because the countable is define with in seed object, which is nested object. Thus, the question is how to destructuring these kinds of objects?

const fruit = {
  seed : {
    countable: 'A fertilized grain, initially encased in a fruit, which may grow into a mature plant.' ,
    botany: 'A fertilized ovule, containing an embryonic plant.',
    uncountable: 'An amount of fertilized grain that cannot be readily counted.'
  },
  definition: 'All produce that contains seeds is botanically classified as a fruit.',
}

let { seed: { countable, botany }, definition } = fruit;

console.log(countable);  //  A fertilized grain, initially encased in a fruit, which may grow...
console.log(botany);  //  A fertilized ovule, containing an embryonic plant.
console.log(definition);  //  All produce that contains seeds is botanically classified as a fruit.

Destructuring with default values

const fruit = {
  seed : {
    countable: 'A fertilized grain, initially encased in a fruit, which may grow into a mature plant.' ,
    botany: 'A fertilized ovule, containing an embryonic plant.',
    uncountable: 'An amount of fertilized grain that cannot be readily counted.'
  },
  definition: 'All produce that contains seeds is botanically classified as fruit.',
}

let { seed: { botany }, definition, sweet = 'Containing a sweetening ingredient.' } = fruit;

console.log(botany);  //  A fertilized ovule, containing an embryonic plant.
console.log(definition);  //  All produce that contains seeds is botanically classified as fruit.
console.log(sweet);  //  Containing a sweetening ingredient.

Computed Object property names and destructuring

const key = 'grapes';
let {[key]: fruit} = { grapes: 'A small, round, smooth-skinned edible fruit.' }

console.log(fruit)  //  A small, round, smooth-skinned edible fruit.

Rest in Object destructuring

Consider rest operator as the last element while unpacking the values from the source element.

let { a, b, ...res } = {a: "first", b: "second", c: "third", d: "fourth", e: "fifth"};

console.log(a); //  first
console.log(b); //  second
console.log(res); //  { c: 'third', d: 'fourth', e: 'fifth' }

Invalid identifier as a property name

Space, dash and special character are not allowed for Object's property name.

let { 'of a person' } = {'of a person': 'Having considerable flesh.'};  //  cannot access property 
let { 'of a person': seed } = {'of a person': 'Having considerable flesh.'}; 
//  we have to rename it for access the value

console.log(seed); //  Having considerable flesh.

The prototype chain is looked up when the object is deconstructed

When deconstructing an object, if a property currently exists not accessed in itself, it will continue to look up along the prototype chain.

const obj = { property: 123 };
obj.__proto__.anotherProto = 456;
let { anotherProto } = obj

console.log(anotherProto);  // 456

JavaScript arrow function

Kaushal — Thu, 16 Apr 2020 17:17:02 +0000

Introducrion

ES6 comes with a new function syntax which looks very different from others. Arrow functions were added in 2015, on the whole to make writing functions with less expression. Instead of using the "function" keyword, we can use an arrow (=>), which made up of an equal sign and a greater-than character (do not get confused with the greater-than-or-equal operator, which is written like >=).

Syntax

const variable = (parameter) => {
  // function body
}

The arrow comes after a list of function's parameters and followed by the function's body. Which is same as,

function functionName () {
  // function body
}

If the function has only one parameter, we can omit the parentheses around the parameter list. If the body is a single expression, rather than a block in braces, that expression will be returned automatically from the function. So, these two function definitions will do the same thing.

const func1 = (x) => { return x*x; };

cosnt func2 = x => x*x;

If function has only a single argument in the argument list, its parameter list is just empty set of parentheses.

const func = () => {
  return "Hello, world";
}

DEV Community: Kaushal

Bring Linux environment to Windows

The steps to do so are outlined below.

WSL includes several ridiculous features:

Number in JavaScript

Introduction

Constructor in Number

Static properties of Number

Number.EPSILON

Number.MAX_SAFE_INTEGER

Number.MAX_VALUE

Number.MIN_SAFE_INTEGER

Number.MIN_VALUE

Number.NaN

Number.NEGATIVE_INFINITY

Number.POSITIVE_INFINITY

Number.prototype

Static methods of Number

Number.isNaN()

Number.isFinite()

Number.isInteger()

Number.isSafeInteger()

Number.parseFloat(string)

Number.parseInt(string, [radix])

Instance methods of Number

Number.prototype.toExponential(fractionDigits)

Number.prototype.toFixed(digits)

Number.prototype.toLocaleString([locales [, options]])

Number.prototype.toPrecision(precision)

Number.prototype.toString([radix])

Number.prototype.valueOf()

Summary

JavaScript data-types

Introduction

Dynamic typing

Primitive

String

Number

BigInt

Boolean

Null

Undefined

Composite

Object

Function

Special

Summary

this keyword in JavaScript

Introduction

this in function context.

this and object conversion

with bind method

this work differently in both Arrow and Normal function

Difference between Arrow and Normal functions.

Arrow function

Difference between normal and arrow functions.

Why we need Arrow function.

When use it.

Not use.

Node.js

Core things in Node.js

proceses object

util module

v8 module

readline module

events module

JavaScript destructuring

Introduction

Syntax

Array destructuring

Assignment is allowed separate from declaration.

We can relinquish(omit) the unnecessary values from the array while destructuring it.

Rest element must be last element

Use as a swapper

Object destructuring

Declaration and assignment

Assigning with new name(rename)

Default value

Default value to newly define local variable

Nested object destructuring

`Number.EPSILON`

`Number.MAX_SAFE_INTEGER`

`Number.MAX_VALUE`

`Number.MIN_SAFE_INTEGER`

`Number.MIN_VALUE`

`Number.NaN`

`Number.NEGATIVE_INFINITY`

`Number.POSITIVE_INFINITY`

`Number.prototype`

`Number.isNaN()`

`Number.isFinite()`

`Number.isInteger()`

`Number.isSafeInteger()`

`Number.parseFloat(string)`

`Number.parseInt(string, [radix])`

`Number.prototype.toExponential(fractionDigits)`

`Number.prototype.toFixed(digits)`

`Number.prototype.toLocaleString([locales [, options]])`

`Number.prototype.toPrecision(precision)`

`Number.prototype.toString([radix])`

`Number.prototype.valueOf()`

with `bind` method