YDKJS 第二次讀書會

     const precisionY = getPrecision(y);

if (precisionX === 0 && precisionY === 0) return x + y;

const powNum = Math.pow(10, Math.max(precisionX, precisionY));

const powX = x * powNum;
const powY = y * powNum;

return (powX + powY) / powNum;
}
const answer = splitWithDot(a, b);
console.log(answer);
toFixed 為銀行進位法，不算是四捨五入。

Undefined
undefined 和 null 型別，都僅有自己本身唯一值的存在：undefined 和 null。
null 是一個空值，或是曾經有過，但不再有的值。
undefined 是一個缺少的值，或是尚未有值。
null 是一個特殊的關鍵字，而非一個識別字，因此不能當作變數想要指定值給他，而 undefined 是一個識別字。
function foo(){
undefined = 2;
//非常不建議這樣做
}
foo();//undefined

function foo(){
‘use strict’
undefined = 2;
//非常不建議這樣做
}
foo();//Error
void operator
undefined 是一個內建的識別字，持有內建的 undefined 值，可以透過 void 運算子取得。

void 運算子會讓任何值變得空無，他不會修改現在的值，能確保的值這個運算式不會回傳任何值。

var a = 42;
console.log(void a, a)// undefined 42
當你要確保一個運算式沒有值，就可以使用 void：

function doSomething(){
if(!APP.ready){
//稍後再試一次
return void setTimeout (doSomething, 100);
//讓 setTimeout 永遠不會有回傳值
}

var result;
//做其他事
return result;
}

if(doSomething()){
// 立即處理下件事
}

var a = false;
function doSomething() {
console.log(‘// note: `APP.ready` is provided by our application’)
if (!a) {
console.log(‘// try again later’)
return void setTimeout( doSomething, 100 );
// setTimeout 的回傳值不會被攔截
}

var result = true;

console.log(‘// do some other stuff’);
return result;
}

console.log(‘// were we able to do it right away?’);
if (doSomething()) {
console.log(‘// handle next tasks right away’);
}
NAN
直翻為「不是一個數字」，較精確的說法是無效的數字、不合格的數字、壞掉的數字。
特別之處在於它永遠不等於自己 NaN !== NaN。
測試它是否為 NaN 可以使用 isNaN()，不過此方法太過NaN了，使他的工作基本上變成「測試看看傳入的東西是不是一個number」
ES6 提供了另外一個替代工具 Number.isNaN()。
Infinity
在 JavaScript 當中除以 0 為無限時，不會產生錯誤，而是產生明確定義，產生 Infinity 這個值，且在 JavaScript 當中還有分正及負的 Infinity。
JavaScript 使用的是有限的數值表示法(IEEE754浮點數)，因此執行運算時有可能發生溢位。
零
在 JavaScript 中提供正的零和負的零，是為了當數值被計算為零的時候，仍然可以保留某些資訊，例如方向。
將負零字串化或是利用比較運算子我們都無法分辨 -0
特殊相等性
在 ES6 有一個新工具可以測試兩個值是否絕對相等，他叫做 Object.is

(..)：

var a = 2 / “foo”;
var b = -3 * 0;

Object.is

(a, NaN);//true
Object.is

(b, -0);//true

Object.is

(b, 0); //false

值 v.s. 參考
JavaScript 當中是以值的型別來控制其值是藉由值的拷貝還是藉由值的參考來指定的。純量基型值都是藉由值的拷貝（null / undefined / string / number / boolean / symbol），object（包含 array 及 function）是傳參考。
要藉由值的拷貝傳入一個複合值，必須動手做一個它的拷貝，讓傳入的值不會仍然指向原複合值，例如使用 slice()
如果要傳入一個純量，但想要它可以被更新，就必須包裹在一個複合值裏面。
利用純量物件無法修改其持有的純量基型值，因為底層的純量基型值是不可變的。
深拷貝及淺拷貝
JSON method 可以轉多層巢狀物件，但不能轉 function。
展開運算子、Object.assign，皆為淺拷貝。
Array.from 為淺拷貝，可以轉陣列，但二維陣列就會指向到舊的陣列。
//Henry
const c = [1,2,[3,4, [5,6]], ‘abc’];

function recursion (x) {
if(typeof(x) === ‘number’) {
return Number(x);
} else if (typeof(x) === ‘string’) {
return String(x);
} else if (Array.isArray(x)) {
let arr = [];
x.forEach(current => {
arr.push(recursion(current));
});
return arr;
}
}

const d = recursion(c);
d[2][2][0] =989;  // 原本的 c 不會被修改到

const e = c;
e[2][2][0] =234; // 原本的 c 會被修改到
//kai
var a = [1, 2, 3, [4, 5]];
var b = Array.from(a);
b[0] = 4;
a // [1, 2, 3, [4, 5]]
b // [4, 2, 3, [4, 5]]
b[3][0] = 10;
a // [1, 2, 3, [10, 5]]
b // [1, 2, 3, [10, 5]]
深拷貝物件的遞迴函式：
function deepCopy(val){
const obj = {…val};
for(item in obj){
if(typeof(obj[item]) === “object”){
obj[item] = deepCope({…obj[item]})
}else{
obj[item] = val[item];
}
}
return obj;

}
深拷貝陣列的遞迴函式：
//json
const arr = [[“23er”, 2, 3], [4, [1, 2, 3], 6], [7, 8, 9]];

function copyArray(x) {
if (typeof (x) !== “object”) return x; //進來的只有object和array
else if (Array.isArray(x)) {
let newArr = [];
for (let i = 0; i < x.length; i++) {
newArr[i] = copyArray(x[i]);
}
return newArr;
}
else {
console.log(‘is object’);
//還沒想物件的deep copy
}
}

let nArr = copyArray(arr);
nArr[1][1][0] = 2;
console.log(arr);
console.log(nArr);
// tomas
const arr = [
1,
2,
3,
[4, 5, 6,
[7]
]
];

const checkHasMoreArray = (arr) =>
Array.isArray(arr) &&
arr.some(item => Array.isArray(item));

const deepCopy = ([head, …arr]) => {
const hasMoreArray = checkHasMoreArray(head);
const result = hasMoreArray
? deepCopy(head)
: [head];

const otherResult = arr.length === 0
? []
: deepCopy(arr);
return [head, …otherResult]
};

console.log(deepCopy(arr));
Immutable 套件：所有的修改值都會被記錄在記憶體中，不會改動原本的資料。