.toFixed() // fix digits after decimal

const num = 1234567/6543 // 188.68515971267004
num.toFixed(2) // show 2 digits only after decimal, 188.68

////// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> //////

.toPrecision() // number of significant digits

const num = 5.123456;

num.toPrecision() // '5.123456'
num.toPrecision(4) // '5.123'
num.toPrecision(1) // '5'

const num = 0.000123
num.toPrecision(5) // '0.00012300'
num.toPrecision(2) // '0.00012'

// note that exponential notation might be returned in some circumstances
(1234.5).toPrecision(2) // '1.2e+3' means 1.2 * 10^3 = 1200

parseInt(str, base) //. converts string to number data-type
// base is opt, defaults to 10, between 2 to 36
.parseFloat(str) //. converts string to floating(decimal) number
.isFinite() 
// checks a number to be finite, 
// by checking number equal to +Infinity or -Infinity
.isInteger() // true if a value is an integer

isNaN() // true if a value is not a number
isNaN("I am a string")

Number.isSafeInteger() // if value is safe for JS
Number.isSafeInteger(Number.MAX_SAFE_INTEGER) // true

Number.MAX_VALUE // largest floating number
Number.MIN_VALUE // smallest floating number

Number.MAX_SAFE_INTEGER // largest integer
Number.MIN_SAFE_INTEGER // smallest integer

Number.NEGATIVE_INFINITY // returns -Infinity
Number.POSITIVE_INFINITY // returns +Infinity

let str = "A new string with words.";

str.toUpperCase()
str.toLowerCase()

str.split(separator|regex, limit) // limit is optional, no. of substrings to return
str.split(' ') // ['A', 'new', 'string', 'has', 'been', 'created']
str.split(' ', 3) // ['A', 'new', 'string']
/**
returns: array
changes the string in variable: FALSE
*/

str.substring(startIdx, endIdx) // endIdx is opt, takes substring from startIdx
// to endIDx, if endIdx is not given then takes from startIdx 
// all the way to the last letter.
str.substring(2, 12) // 'new string'
/**
returns: string
changes the string in variable: FALSE
*/

str.slice(startIdx, endIdx)
str.slice(-6, -1) // returns "words"

let name = "Yash"
name = "Priyam"

const str = "Yash"
str[1] // a
str[1] = "e"
str // "Yash"

str.endsWith(searchStr, endIdx) // endIdx is opt, if given searches upto endIdx
str.endsWith("words") // true
str.endsWith("A") // false
/**
returns: TRUE or FALSE
changes the string in variable: FALSE
*/

str.startsWith(searchStr, startIdx)// startIdx is opt
str.startsWith("A") // true
/**
returns: TRUE or FALSE
changes the string in variable: FALSE
*/


str.includes(searchStr, idx) // idx is opt, search starts from idx
str.includes("string") // TRUE
str.includes("STRING") // FALSE
/**
returns: TRUE or FALSE
changes the string in variable: FALSE
*/

str.trim() // removes whitespace from start and end of string
str.trimEnd()
str.trimStart()

str.at(-3) // gives character at given index (takes -ve index also)
str.charAt(2) // gives character at given index (takes +ve index only)


str.charCodeAt(index) 
// returns an integer between 0 and 65535 
// representing the UTF-16 code unit of the 
// character at the given index.
str.codePointAt(index)
str.fromCharCode()
str.fromCodePoint()

/*
 * Characters in a string are indexed from left to right. 
 * The index of the first character is 0, and 
 * last character str.length - 1.
 * Unicode code points range from 0 to 1114111 (0x10FFFF). 
 * In UTF-16, each string index is a code unit with value 0 – 65535. 
 * Higher code points are represented by a pair of 16-bit surrogate pseudo-characters. 
 * Therefore, codePointAt() returns a code point that may span two string indices.
 * */

str.search(regex)
/**
returns: idx of searched char, OR -1
changes the string in variable: FALSE
*/


str.match(regex)
/**
returns: an array of matches
changes the string in variable: FALSE
*/
str.matchAll()


str.replace(str | regex, replaceStr | function) 
// if str, then only 1st match is replaced

str.replaceAll(str | regex, replaceStr | function) 
// all the matches are replaced