# 嬿媜 q1~q5_code review
### q1
#### playMovieMessage 命名
改為 IsPlayMovie 或 showMovieStatus？
### verify
#### IsPositiveInteger 命名
命名叫 IsPositiveInteger 是正整數，但是 0 不是正整數
```javascript!
export function IsPositiveInteger(input){
if(Number(input) < 0){
throw new Error('請輸入正整數^^');
}
}
```
#### ==符號有沒有擋到要確認一下==
### q2
宣告的 function 可以提出去外面，比較好閱讀。
可以再看一下巢狀要怎麼改。
### q3
#### calculateTicketPrice 命名
改為 GetTicketPriceByAge？
#### calculateTicketPrice
確定不會動的東西都用 const 先宣告，然後再修改其他情況。
```javascript!
// 原本寫法
export function calculateTicketPrice(userInput) {
let ticketPrice = 400;
if (userInput <= 6 || userInput >= 65) {
ticketPrice = ticketPrice * 0.5;
return `您的票價為：${ticketPrice} 元`;
} else {
return `您的票價為：${ticketPrice} 元`;
}
}
// 可以改為
export function calculateTicketPrice(userInput) {
const originalPrice = 400;
const discount = 0.5;
let ticketPrice;
if (userInput <= 6 || userInput >= 65) {
ticketPrice = ticketPrice * discount;
return `您的票價為：${ticketPrice} 元`;
} else {
ticketPrice = originalPrice;
return `您的票價為：${ticketPrice} 元`;
}
}
```
### q4
#### 驗證放一起
```javascript!
if(Number(userInput) === 0) {
console.log(`請輸入比 0 大的數字^^`);
main();
} else {
...
}
// 這個 0 的可以搬到後面的驗證一起
```
#### 讓 let i = 0 always 從 0 開始
通常不會改這個初始值
### test 現在是算式和總和分開測
不知道最終 console.log() 出來的東西是不是你想要的，可以放在一起測，測一整個 main
### 推薦看
array.reduce
Code Completed Ch11
# 季芳 q1~q5_code review
### q1
#### 1. 用 let 的用意？後面會對這個重新賦值嗎？
```javascript!
let playMovieMessage = playMovie(userInput);
```
季芳目前都是 const 用到底，如果變數要重新賦值才會改成 let。
#### 2. 知道rl是非同步嗎？
- 還有另一個套件，同步的： [heapwolf/prompt-sync: a synchronous prompt for node.js](https://github.com/heapwolf/prompt-sync)，會等使用者輸入之後才會做下一步。
#### 3. 命名：大駝峰小駝峰
目前看都寫小駝峰，但 verify.js 裡面的`Is…`是大駝峰，命名時大小駝峰選一個用就好。
#### 4. `checkInputValidity`
這個 function 放在 verify 位置有點奇怪。
目前 verify 大多放獨立驗證的 function，`checkInputValidity`更像是容器在對內容作抽換。
可以看一下 [Jade](https://gitlab.com/dwatow/j1/-/blob/jade/Jade/common_module/validators.js) 寫的驗證。
#### 5. 沒驗到科學記號e
`1e01`
目前是從**使用者輸入**去驗。
還有一種驗法是：只能輸入什麼，最後一個用驗證用正則擋。
### q1 test
從執行結果看，執行結果沒有被描述出來。
Chirs 有提過：測試可能會給不懂程式的人看，假設這裡是給業主看的。
單從這邊的描述看不出測完的輸出結果，只看出有通過，但通過的結果是什麼不知道。這樣不會知道有沒有符合功能的需求。
- 可以用`describe` 當作容器把內容整理一下。 [Globals · Jest](https://jestjs.io/docs/api#describename-fn)
可以參考 [季芳](https://gitlab.com/-/ide/project/dwatow/j1/edit/FangLee/-/01/Q1module.test.js) 的，使用 describe 看看
```javascript!
import { Q1 } from "./Q1module.js";
describe("Q1：好想電影院規定除非完全沒有客人買票，否則就算只有一位顧客也照常播放電影，讓使用者輸入客人的人數，並用「!」判斷人數，不為零顯示「照常播放電影」。", () => {
test(`輸入"10"，會輸出"照常播放電影"`, () => {
expect(Q1("10")).toBe("照常播放電影");
});
test(`輸入"0"會輸出"不播放電影"`, () => {
expect(Q1("0")).toBe("不播放電影");
});
});
describe("測試 Q1 不會輸出", () => {
test(`輸入"10"，不會輸出"不播放電影"`, () => {
expect(Q1("10")).not.toBe("不播放電影");
});
test(`輸入"0"，不會輸出"照常播放電影"`, () => {
expect(Q1("0")).not.toBe("照常播放電影");
});
});
describe("測試 Q1 以下都會拋出異常", () => {
test("無輸入", () => {
expect(() => Q1("")).toThrow();
});
test("輸入空格", () => {
expect(() => Q1(" ")).toThrow();
});
test("輸入+0", () => {
expect(() => Q1("+0")).toThrow();
});
test("輸入-0", () => {
expect(() => Q1("-0")).toThrow();
});
test("輸入0.5", () => {
expect(() => Q1("0.5")).toThrow();
});
test("輸入-5", () => {
expect(() => Q1("-5")).toThrow();
});
test("輸入中文", () => {
expect(() => Q1("中文")).toThrow();
});
test("輸入english", () => {
expect(() => Q1("english")).toThrow();
});
});
```
### q2
1. 主程式裡面兩個問題有點巢狀 *Callback Hell*，想一下要怎麼把第二題提出來。
- 第一題的輸入傳到第二題
2. 可以安裝 [Code Spell Checker - Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker)，會幫你檢查拼錯字(藍色底線)。
3. 同第一題使用 let 宣告的原因
4. 驗證完沒有轉型
### q3
1. 驗證完沒有轉型
2. calculateTicketPrice
```javascript!
// before
export function calculateTicketPrice(userInput) {
let ticketPrice = 400;
if (userInput <= 6 || userInput >= 65) {
ticketPrice = ticketPrice * 0.5; // 這裡會直接改到ticketPrice本身，ticketPrice會變成200
return `您的票價為：${ticketPrice} 元`;
} else {
return `您的票價為：${ticketPrice} 元`;
}
}
// after
export function calculateTicketPrice(userInput) {
const ticketPrice = 400;
if (userInput <= 6 || userInput >= 65) {
return `您的票價為：${ticketPrice * 0.5} 元`;
// 這樣ticketPrice還是400
} else {
return `您的票價為：${ticketPrice} 元`;
}
}
```
### q4
#### 1. `Number(userInput) === 0` 應該也是在做驗證吧？
這個可以收在`checkInputValidity`裡面，另外提到外面用if/else處理的原因是？
#### 2. 驗證完沒有轉型
#### 3. createFormula：`const n = input;`
這一行的用意是什麼？不能直接拿 input 去寫嗎？
通常不會用單一字母`n`來命名，也不會用簡寫。
#### 4. gstSum：結構很巢狀
不好讀：function 包 function，然後又if/else裡面包if/else，可以想一下怎麼拆成好讀一點的結構。
```javascript!
// 原本
function accumulate(currentInput, originalTotal) {
let currentTotal = originalTotal;
let currentValue = Number(currentInput);
if (currentValue === 1) {
currentTotal = currentTotal + currentValue;
} else {
if (currentValue % 2 === 0) {
currentTotal = currentTotal + currentValue;
} else {
currentTotal = currentTotal - currentValue;
}
return accumulate(currentValue - 1, currentTotal); // 要寫 return 因為要把 total 的值傳給下一個呼叫的自己
}
return currentTotal;
}
export function getSum(input) {
const total = accumulate(input, 0);
return total;
}
```
```javascript!
// 改寫
function accumulateSum(currentNumber, runningTotal) {
const isMinimumValue = currentNumber === 1;
if (isMinimumValue) {
return runningTotal + currentNumber;
}
const updatedTotal = getUpdatedTotal(currentNumber, runningTotal);
return accumulateSum(currentNumber - 1, updatedTotal);
}
function getUpdatedTotal(number, total) {
const currentNumberIsEven = number % 2 === 0;
if(currentNumberIsEven) {
return total + number;
}
return total - number;
}
export function getSum(number) {
const sumResult = accumulateSum(number, 0);
return sumResult;
}
```
### q5
#### 1. umleven、umlevenFormula
這兩個 function 裡面的內容看起來是重複的，可以想一下怎麼把重用的部分抽出來。
```
```
- 如果對迴圈練熟了，可以嘗試使用array method
### 推薦看
array method
# 阿傑 q1~q5_code review
### rl
```javascript!
import { createInterface } from 'readline';
const rl = createInterface({
input: process.stdin,
output: process.stdout
});
export { rl }; // 可以不用包 {}，因為沒有要做其他事情
```
### verify
```javascript!
export function IsNotEmpty(input) {
if (!(String(input).trim().length > 0)) {
throw new Error('請輸入東西^^');
}
}
// rl 拿到其實就是 String 了，不用轉
export function IsNotEmpty(input) {
if (!(input).trim().length > 0)) {
throw new Error('請輸入東西^^');
}
}
// 可改為
export function IsNotEmpty(input) {
if (!(input).trim().length) {
throw new Error('請輸入東西^^');
}
}
```
怎麼知道自己在寫啥:)
```javascript!
!(input).trim().length
-> (input) 是拿到什麼？字串(假設我輸入3)
!(input).trim().length
-> !"3".trim().length
trim() 是什麼？會把前後空白都去掉的 funciton，會回傳字串
-> !"3".length
length 是什麼？會把字串轉為字串長度的 funciton，會回傳數字
-> !1
!1 會轉為布林值
1 會轉為 true
所以 !true 是 false
```
### 注意各處 let 考慮是否用 const
### isNaN / Number.isNaN
### Number.isInteger 看有沒有其他可以轉為數字的方式
[參考](https://dev.to/sanchithasr/7-ways-to-convert-a-string-to-number-in-javascript-4l)
###
<!-- # Chris q1~q5_code review -->
### q2
```javascript!
// 原本寫法
export function compareRemainders(firstNumber, secondNumber) {
if (firstNumber % 3 === secondNumber % 3) {
return `${firstNumber} 和 ${secondNumber} 餘數相同`;
} else {
return `${firstNumber} 和 ${secondNumber} 餘數不相同`;
}
}
// 可以改為
export function compareRemainders(firstNumber, secondNumber) {
const fistReminder = firstNumber % 3
const secondReminder = secondNumber % 3
if (fistReminder === secondReminder) {
return `${firstNumber} 和 ${secondNumber} 餘數相同`;
} else {
return `${firstNumber} 和 ${secondNumber} 餘數不相同`;
}
}
// 甚至可以讓這隻 function 只回傳布林值，讓主程式做印出
export function areRemindersEqual(firstNumber, secondNumber) {
const fistReminder = firstNumber % 3
const secondReminder = secondNumber % 3
return fistReminder === secondReminder
}
// main
const result = areRemindersEqual ? `${firstNumber} 和 ${secondNumber} 餘數相同` : `${firstNumber} 和 ${secondNumber} 餘數不相同`
console.log(result);
```
### 一個 function 只做一件事
### 讓 let i = 0 從 0 開始
如果要從一開始跑的可以這樣寫
```javascript!
for(let i = 0; i < n; i++) {
if(i === 0) {
continue;
}
...
}
```
### 驗證用一個 陣列跑forEach
```javascript!
export function checkInputValidity(input, moreValidation){
//basic
isNotEmpty(input);
isNumber(input);
isInteger(input);
isPositiveInteger(input);
//
moreValidation.forEach(validation => {
validation(input)
});
}
// 這樣呼叫
checkInputValidity(userInput, [isNotZero, OverFour, isEven]);
```
### 閉不閉包
```javascript!
// 原本
export function calculateSum(input) {
const total = accumulate(input);
return total;
function accumulate(currentInput) {
// side effect
let total = 0;
let currentValue = Number(currentInput);
if (currentValue === 1) {
total = total + currentValue;
console.log(total)
} else {
if (currentValue % 2 === 0) {
total = total + currentValue;
console.log(total)
} else {
total = total - currentValue;
console.log(total)
}
accumulate(currentValue - 1);
}
return total;
}
}
```
> 怕有副作用問題，所以改寫為變數就作用在自己的 function 裡面，再回傳出去
```javascript!
// 阿傑調整
export function calculateSum(input) {
const total = accumulate(input, 0);
return total;
function accumulate(currentInput, originalTotal) {
let currentTotal = originalTotal;
let currentValue = Number(currentInput);
if (currentValue === 1) {
currentTotal = currentTotal + currentValue;
} else {
if (currentValue % 2 === 0) {
currentTotal = currentTotal + currentValue;
} else {
currentTotal = currentTotal - currentValue;
}
return accumulate(currentValue - 1, currentTotal); // 要寫 return 因為要把 total 的值傳給下一個呼叫的自己
}
return currentTotal;
}
}
```
# Chris q1~q5_code review 🔥๛๛๛ก(ｰ̀ωｰ́ก )
### 到底要測什麼？測試應該如何訂定範圍、邊界
> 就是測：使用者輸入到輸出。
#### 現在我 q5 測的是：算式測一個，答案測一個
```javascript!
但是其實我們要測的是："輸入" 印出 "算式=答案" >> 這一整串
原本測的方式
輸入 4
算式對，輸出 2*4，答案也對，輸出 8
但其實介面會不會是 2*4 8 還是 2*4 = 8
這你不會知道，測試不會噴錯
所以建議要"包起來一起測試"。
測輸入到輸出，都測到了，邏輯也跟介面分開(還是不太懂這句的意思)。
```
```javascript!
// 原本寫法
function main() {
rl.question('來算 2*4 + 4*6 + 6*8...+(n-2)*n 吧，請輸入一個 至少為 4 的偶數 n：', (userInput) => {
try {
checkInputValidity(userInput);
const umlevenSum = getUmlevenSum(Number(userInput));
const umlevenFormula = getUmlevenFormula(Number(userInput));
const result = `${umlevenFormula} = ${umlevenSum}`;
return result;
rl.close();
} catch (error) {
console.log(error.message);
main();
}
});
}
main();
// 改為
function main() {
rl.question('來算 2*4 + 4*6 + 6*8...+(n-2)*n 吧，請輸入一個 至少為 4 的偶數 n：', (userInput) => {
try {
const result = Q5(userInput);
console.log(result);
rl.close();
} catch (error) {
console.log(error.message);
main();
}
});
}
main();
// 就測 Q5 一整個就好
function Q5(userInput) {
checkInputValidity(userInput);
const umlevenSum = getUmlevenSum(Number(userInput));
const umlevenFormula = getUmlevenFormula(Number(userInput));
const result = `${umlevenFormula} = ${umlevenSum}`;
return result;
}
```
#### 要測輸入錯誤的時候會怎樣
```javascript!
// 測試例子至少測這些：
最小值
最小值-1
最大值 -> 要設一個值給他，錯誤會是我設定的 Error，想語言極限到哪裡
最大值+1
其他一堆不正常的輸入
```
### main()
export 拿掉
### verify
```javascript!
parseInteger.parseFloat -> parse 是解析 -> 解析什麼？ 字串
isNotEmpty 你的命名有隱含是要放字串，所以裡面不一定要轉態
其實有兩派：
1. 丟什麼轉好再執行，避免 garbage in(丟數字會報錯的)
2. Chris 是不轉派的，自己寫自己用的，不做這件事就會跑比較快(少一個 stack)
寫容錯率很高 funciton 通常就是要給別人用的
```
### 對象
```javascript!
要想一下這個東西是要"給哪個對象用的"
舉例：我的驗證是我自己在用的，所以可以不用轉態，錯了再噴錯、自己看得到就好了
對象會影響你寫程式的錯誤處理機制！
```
### checkInputValidity 可以分兩段
```javascript!
export function checkInputValidity(input) {
isNotEmpty(input);
isStartsWithPlusOrMinusZero(input);
isNumber(input);
isInteger(input);
isPositiveInteger(input);
overFour(input);
isEven(input);
}
// 可以分為兩段，比較好區別驗證字串和驗證數字區
export function checkInputValidity(input) {
isNotEmpty(input);
isStartsWithPlusOrMinusZero(input);
isNumber(input);
isInteger(input);
isPositiveInteger(input);
overFour(input);
isEven(input);
}
```
### isNaN / Number.isNaN，我還是很混亂但總之先用 Number.isNaN
Number.isNaN
> The boolean value true if the given value is a number with value NaN. Otherwise, false.
如果給定值是值為 NaN 的數字，則布林值 true。否則為 false。
-> 只有數字型別的 NaN 丟的進來，其他都false
```javascript!
NaN 字串轉型為數字會是 NaN
Number("NaN") // NaN
-
Number.isNaN("NaN") // false
isNaN("NaN") // true
isNaN("NaN") // true
isNaN("ddd") // true
isNaN(Number("NaN")) // true
isNaN(Number("ddd")) // true
Number.isNaN("NaN") // false
Number.isNaN("ddd") // false
Number.isNaN(Number("NaN")) // true
Number.isNaN(Number("ddd")) // true
```
### 沒擋到
```javascript!
1e2
0x110
0xFE
因為要擋這些事情，所以要對數字型別非常清楚/有什麼表達方式
學進制轉換( 12轉8 啊，8轉10 啊，才有辦法知道這些事情)
```
### 科學記號補充
[IEEE 754](https://zh.wikipedia.org/zh-tw/IEEE_754)
[從 IEEE 754 標準來看為什麼浮點誤差是無法避免的](https://medium.com/starbugs/see-why-floating-point-error-can-not-be-avoided-from-ieee-754-809720b32175)
[BigInt](https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
### 有意識の注意型別
```javascript!
寫 function 的時候注意"輸入和輸出各是什麼型別"
看完上面補充，可以知道為什麼JS會有這麼多數字型別
```
### 驗證輸入 0，我還是很混亂
```javascript!
// 輸入 0，不會跑錯誤訊息，
// 沒擋到 0，會直接跑 overFour()那段訊息
export function isPositiveInteger(input){
if(Number(input) < 0){
throw new Error('請輸入正整數^^');
}
}
export function overFour(input) {
if(Number(input) < 4) {
throw new Error('請輸入至少為 4 的數字^^');
}
}
// 改為：
export function isPositiveInteger(input){
if(Number(input) <= 0){
throw new Error('請輸入正整數^^');
}
}
```
### why 要寫 verify
> 引導熟悉型別的表達方式
### 不習慣這樣那樣讀
(使用多運算子時，會有運算先後順序的差別，不想去記)
```javascript!
const isMinimumSum = number === minimumValidNumber;
```
```javascript!
// 改寫 function(Chris 的習慣)
funciton isMinimumSum() {
return number === minimumValidNumber;
}
if(isMinimumSum()) {
...
}
// 或寫括號
const isMinimumSum = (number === minimumValidNumber);
```
### 哲學問題：轉態後才進 function / 進 function 才轉態
```javascript!
const finalTicketPrice = getTicketPriceByAge(Number(userInput));
or
function getTicketPriceByAge() {
const nUserInput = Number(userInput);
...
}
```
>判別標準：它是屬於誰的
>funciton 這一步，該煩惱它的型別嗎？
```javascript!
Chris 偏好轉型完再進 function，因為我就"認定裡面的東西一定是這個型別"
這個功能本身是假設好型別的，不要背負著轉態這件事情，我知道我要轉、而且我也轉好了！
```
### 匈牙利命名法
userInput 轉態完可以命名為 `nUserInput?`，[歷史看這裡](https://ithelp.ithome.com.tw/articles/10203983)
### return 要 return 一個 result 嗎
```javascript!
// 這個 result 像是中性的命名
const umlevenFormulaResult = `${getUmlevenFormula(number - 2)} + ${(number - 2)}*${number}`;
return umlevenFormulaResult;
// Chris 分享：
看到這串會先看到等號，咦，ok 他們相等，然後等號右邊和等號左邊名稱很像
左邊本就是右邊的結果，如果這個命名沒有特殊意義(這會有點像沒有命名)，Chris 會直接寫 return。
如果是 array method 也不太會命名，就直接 return
除非超難讀，因為不會影響除錯閱讀速度，他只有要 return 沒有要做什麼處理
```
### q5 可以試試看用算式直接算答案
```javascript!
// 第一種：eval
eval('2*4 + 4*6') // 32
// 第二種：new Funciton
var f = new Function('return 2*4 + 4*6'); // 宣告
f(); // 32
```
### q1 - isPlayMovie
```javascript!
// 原本寫法像 over design 🥵
export function isPlayMovie(customerCount) {
const hasCustomer = (Number(customerCount) !== 0);
return hasCustomer;
}
export function showMovieStatus(isMoviePlaying) {
if (isMoviePlaying) {
return '今日營業中，放映電影:)';
} else {
return '今天休假，暫停放映:(';
}
}
```
```javascript!
// 簡潔寫法，回傳一個布林值
export function showMovieStatus(customerCount) {
const isMoviePlaying = (Number(customerCount) !== 0);
if (isMoviePlaying) {
return '今日營業中，放映電影:)';
} else {
return '今天休假，暫停放映:(';
}
}
```
### q1 - showMovieStatus
```
他不是狀態碼，可以命名為一個公告文字之類的
```
### q3 - getTicketPriceByAge 的 const 把變數都先列出來
```javascript!
// 原本寫法
export function getTicketPriceByAge(age) {
const originalTicketPrice = 400;
const maxChildAge = 6;
const minSeniorAge = 65;
const discountRate = 0.5;
const isChild = age <= maxChildAge;
const isSenior = minSeniorAge <= age;
if (isChild || isSenior) {
return `您的票價為：${originalTicketPrice} 元`;
} else {
const discountedTicketPrice = originalTicketPrice * discountRate;
return `您的票價為：${discountedTicketPrice} 元`;
}
}
```
```javascript!
// Chris 寫法
export function getTicketPriceByAge(age) {
const originalTicketPrice = 400;
const maxChildAge = 6;
const minSeniorAge = 65;
const discountRate = 0.5;
if (maxChildAge < age && age < minSeniorAge) {
return `您的票價為：${originalTicketPrice} 元`;
} else {
const discountedTicketPrice = originalTicketPrice * discountRate;
return `您的票價為：${discountedTicketPrice} 元`;
}
}
// 如果下次 maxChildAge < age && age < minSeniorAge 又有其他新的意思，再把它變成一個新的變數
```
### 德摩根定理
```javascript!
對符號做思考
! 先加上去邏輯顛倒
! 對符號乘法分配率對符號做顛倒邏輯
```
### 額外宣告變數好嗎
```javascript!
const finalTicketPrice = getTicketPriceByAge(Number(userInput));
console.log(finalTicketPrice);
v.s.
console.log(getTicketPriceByAge(Number(userInput)));
// 第一種寫法 - 會好讀、好維護、好測試結果，但是否有需要考慮額外宣告變數的內存？
//第二種寫法 - 可能在沒有那麼複雜的時候可以用
```
```javascript!
思考：左右兩邊有重複的命名，是否有必要，這會決定"這個變數有沒有存在價值"，而不是這個寫法怎麼樣。
舉例：三角函數，爆算了一座山的高度
給左邊的結果命名：玉山高度 or 三角函數結果
前者就比較具有意義，後者就乾脆直接 return 算了
但結論是自己要看起來舒服。
而可讀是要"過自己那一關"，是自己過幾個月回來也是要可讀。
```
### 熟悉度
```javascript!
要考慮到協作的人的熟悉度
你都寫柯里化，團隊的新手都來問你
其實可以寫簡單一點一般寫法，然後你可以做自己的事XD
```
### 看 code 的時候不要靠腦子的記憶，全部用眼睛看出來
```javascript!
可以試試看不靠記憶去讀，這樣才不會一直寫的東西都因為你知道，所以看得出來，但別人看不出來
```
### 哲學問題 - 檔案分類方式，不要為了分檔案分檔案
```javascript!
1. 你喜歡就好
2. 都嘗試看看選個好讀的
3. 方便除錯
但是之後你要選一個對自己來說"最簡單"的為優先(先簡單再好用)
不知道要選什麼，就隨便選一個方法，去體驗：為什麼要分開？分開是適合的嗎？之後不夠用，就知道另外一個好處是什麼了。
```
### 目前我的可以怎麼分檔
```javascript!
可以試試看用 verify 就好，每隻的 validation 不用分(放到Q5)，Q5 拉出去
import { checkInputValidity } from './modules/validation.js';
import { getUmlevenSum, getUmlevenFormula } from './modules/umleven.js';
這兩個就會出現在 Q5
```
### 滿幾個月了，為什麼大家 J1 都寫超過一個月XD
```javascript!
不用把所有語法弄懂再繼續下去，趕快把它寫一寫
但重要的是：你的想法要跟語法一致！
-
function：
四種寫法可以就好(建構式、一般呼叫、method、立即執行)
忍者一和二以 ES6 為分水嶺(推忍者，其他都是輔助書)
型別：
盡量去認識就好，有遇到記得，有遇到記得，不用急著一次把他認識完
多的是機會，多的是認識這語法的機會～
認為覺得去認識測試，語意語法合在一起，時間拉長、熟悉度會提高，因為這是沒有標準答案的問題，需要時間去醞釀，語法就是看語法書學就好
鼓勵有問題馬上問，不用等看 code 的時候問即時問
記憶新鮮度降低，就不會覺得是痛點了，所以馬上問是最好的。
結論：速度是正常的，不用擔心。
```
### 要學哪個框架？
```javascript!
學框架重要的是學觀念。
(React 文件寫得比較好)
學哪一個都沒關係，會 Vue 也可以找 React 和 Angular 工作。
求職重要的是看你可不可以很快學一個東西。
```
Sign in with Wallet
Connect another wallet