何必驕枉過正, 我一直都係話三思先用if, if對底層係好重要
但好多時咩為之靚code唔係我扔條絕對rule出黎就可以寫到
寫code前三思好重要
唔明有咩問題，我未見過有program冇if
sorting點樣唔用if寫到
追post pls
睇唔到邊到有解釋同理據先問
design pattern 有冇if 對真正 寫logic需唔需要if冇衝突
readability depends on點develop，if唔係主因
以前讀hardware if都唔係cost最expensive
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
of course, I am just writing them out separately to enhance readability.
你分開兩個variable對初學者要一步步係易睇d,
但要比人見到fp可以幾簡潔要show埋後面,
睇下個loop可以點樣慢慢變成一句
而你可以一眼望出佢做緊乜
我會話4段加埋先係一個complete example
其實OOP同FP兩樣野無衝突，而且work得好好添
OOP畫class diagram, define完interface之後
點樣implement可以換FP思維去做
同時可以好好組織project structure 同控制data flow
OOP本身個object係stateful, 自己顧自己
我諗你想講嘅係implement果時,
用埋immutable個思維, 唔改internal state,
每次要改都變成return一個新既object出黎
design係互相有幫助, 如果考慮埋fp implement,
你一開始諗data flow就會預埋點先真正uni-direction
唔驚d data中間比人改左就輕輕鬆鬆等收工
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0;
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
第一個function仲用埋global variable
屌 sor
javascript 既話用strict mode
how would it affect my code?
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0;
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
第一個function仲用埋global variable
屌 sor
how would it affect my code?
係function打global varibale會鬧你
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0;
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
第一個function仲用埋global variable
屌 sor
how would it affect my code?
係function打global varibale會鬧你
直接用ES6寫可以唔洗打"use strict"
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0;
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
第一個function仲用埋global variable
屌 sor
how would it affect my code?
係function打global varibale會鬧你
直接用ES6寫可以唔洗打"use strict"
巴打有冇追es7 / 其他 experimental feature
有annotation, async await 果d
追唔哂, 我淨係寫babel-presets-es2015包嘅野
最多寫react嘅時候會加埋jsx syntax
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0;
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
第一個function仲用埋global variable
屌 sor
how would it affect my code?
係function打global varibale會鬧你
直接用ES6寫可以唔洗打"use strict"
巴打有冇追es7 / 其他 experimental feature
有annotation, async await 果d
追唔哂, 我淨係寫babel-presets-es2015包嘅野
最多寫react嘅時候會加埋jsx syntax
寫緊Angular 4, 當然日日寫啦😎
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0;
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
第一個function仲用埋global variable
屌 sor
how would it affect my code?
係function打global varibale會鬧你
直接用ES6寫可以唔洗打"use strict"
巴打有冇追es7 / 其他 experimental feature
有annotation, async await 果d
追唔哂, 我淨係寫babel-presets-es2015包嘅野
最多寫react嘅時候會加埋jsx syntax
寫緊Angular 4, 當然日日寫啦😎
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0;
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
第一個function仲用埋global variable
屌 sor
how would it affect my code?
係function打global varibale會鬧你
直接用ES6寫可以唔洗打"use strict"
巴打有冇追es7 / 其他 experimental feature
有annotation, async await 果d
追唔哂, 我淨係寫babel-presets-es2015包嘅野
最多寫react嘅時候會加埋jsx syntax
寫緊Angular 4, 當然日日寫啦😎
已經用緊async/await
返唔到轉頭
callback hell 拜鳩拜
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0;
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
第一個function仲用埋global variable
屌 sor
how would it affect my code?
係function打global varibale會鬧你
直接用ES6寫可以唔洗打"use strict"
巴打有冇追es7 / 其他 experimental feature
有annotation, async await 果d
追唔哂, 我淨係寫babel-presets-es2015包嘅野
最多寫react嘅時候會加埋jsx syntax
寫緊Angular 4, 當然日日寫啦😎
但你個名
how would it affect my code?
係function打global varibale會鬧你
直接用ES6寫可以唔洗打"use strict"
巴打有冇追es7 / 其他 experimental feature
有annotation, async await 果d
追唔哂, 我淨係寫babel-presets-es2015包嘅野
最多寫react嘅時候會加埋jsx syntax
寫緊Angular 4, 當然日日寫啦😎
已經用緊async/await
返唔到轉頭
callback hell 拜鳩拜
d promise寫得好d code都拍得好靚架
假設我d code都乖乖地咁拍左邊係咁then,
呢d情況下async await會差幾遠
how would it affect my code?
係function打global varibale會鬧你
直接用ES6寫可以唔洗打"use strict"
巴打有冇追es7 / 其他 experimental feature
有annotation, async await 果d
追唔哂, 我淨係寫babel-presets-es2015包嘅野
最多寫react嘅時候會加埋jsx syntax
寫緊Angular 4, 當然日日寫啦😎
已經用緊async/await
返唔到轉頭
callback hell 拜鳩拜
d promise寫得好d code都拍得好靚架
假設我d code都乖乖地咁拍左邊係咁then,
呢d情況下async await會差幾遠
但唔記得await就爽yy
試過
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
Why not define the abs function first? (Maybe I'm wrong and abs is assumed to have been defined or imported from a maths library)
Also why not change to ES2015 (or ES6) style of defining a function? (It's now in 2017 and ES6 has already been in effect for quite a while!!!)
If I were you, I would add/change the code as follows:
e.g. under node:
> abs_sum([1,2,3,-4,-5]);
15
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
Why not define the abs function first? (Maybe I'm wrong and abs is assumed to have been defined or imported from a maths library)
Also why not change to ES2015 (or ES6) style of defining a function? (It's now in 2017 and ES6 has already been in effect for quite a while!!!)
If I were you, I would add/change the code as follows:
e.g. under node:
> abs_sum([1,2,3,-4,-5]);
15
你唔寫class咁用哂lambda梗係冇問題
但係lambda絕對唔係function既short hand,
this is so 伏
用冇問題, 但要記住lambda唔係short hand
[quote][quote][quote][quote][quote][quote]d promise寫得好d code都拍得好靚架
假設我d code都乖乖地咁拍左邊係咁then,
呢d情況下async await會差幾遠
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
Why not define the abs function first? (Maybe I'm wrong and abs is assumed to have been defined or imported from a maths library)
Also why not change to ES2015 (or ES6) style of defining a function? (It's now in 2017 and ES6 has already been in effect for quite a while!!!)
If I were you, I would add/change the code as follows:
e.g. under node:
> abs_sum([1,2,3,-4,-5]);
15
你唔寫class咁用哂lambda梗係冇問題
但係lambda絕對唔係function既short hand,
this is so 伏
用冇問題, 但要記住lambda唔係short hand
有乜嘢伏? 真心請教!
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
Why not define the abs function first? (Maybe I'm wrong and abs is assumed to have been defined or imported from a maths library)
Also why not change to ES2015 (or ES6) style of defining a function? (It's now in 2017 and ES6 has already been in effect for quite a while!!!)
If I were you, I would add/change the code as follows:
e.g. under node:
> abs_sum([1,2,3,-4,-5]);
15
你唔寫class咁用哂lambda梗係冇問題
但係lambda絕對唔係function既short hand,
this is so 伏
用冇問題, 但要記住lambda唔係short hand
有乜嘢伏? 真心請教!
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
Why not define the abs function first? (Maybe I'm wrong and abs is assumed to have been defined or imported from a maths library)
Also why not change to ES2015 (or ES6) style of defining a function? (It's now in 2017 and ES6 has already been in effect for quite a while!!!)
If I were you, I would add/change the code as follows:
e.g. under node:
> abs_sum([1,2,3,-4,-5]);
15
你唔寫class咁用哂lambda梗係冇問題
但係lambda絕對唔係function既short hand,
this is so 伏
用冇問題, 但要記住lambda唔係short hand
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
Why not define the abs function first? (Maybe I'm wrong and abs is assumed to have been defined or imported from a maths library)
Also why not change to ES2015 (or ES6) style of defining a function? (It's now in 2017 and ES6 has already been in effect for quite a while!!!)
If I were you, I would add/change the code as follows:
e.g. under node:
> abs_sum([1,2,3,-4,-5]);
15
你唔寫class咁用哂lambda梗係冇問題
但係lambda絕對唔係function既short hand,
this is so 伏
用冇問題, 但要記住lambda唔係short hand
算係架已經（最少Java班developer恨左好耐)
只係睇係從咩角度講，lambda提供左first class function 既既environment得你可以寫出FP way
有乜嘢伏? 真心請教!
function Whatever() {
this.x = -10;
this.abs = () => Math.abs(this.x);
}
let w = new Whatever();
w.abs(); // 10
lambda個this scope會跟左function個this scope
傳統function你要做呢樣野
function Whatever() {
var self = this;
this.x = -10;
this.abs = function () {
return Math.abs(self.x); // 用 this 你就食左屎
};
}
babel transpile果陣會自動幫lambda搵定個this scope
我記得有frd用lambda中過伏, 唔記得detail
但係至少由此可見lambda同function嘅sematics係唔同
如果個program冇object果類野唔洗reference this就ok
即刻寫可能1999, 有問題我再講
FP 真係會幫到clean code
因為會令我地學識點將大件的野拆細來做
仲有higher order functions is a must for clean code
For example: 如果我地有個list of numbers，之後我地想搵所有number 的 absolute value 之和。
可能你會好想咁寫:
function f(xs){
var sum = 0; // 其他人有講, 我諗純typo姐
for(var i = 0; i < xs.length; i++){
sum += abs(xs[i]);
}
return sum;
}
但靚d 的方法係:
function f(xs){
var abs_xs = xs.map(abs);
var sum = abs_xs.reduce((x, y) => x+y, 0);
return sum;
}
啱啱入黎
專業寫fp係第二個function根本無var
function abs_sum(xs) {
return xs.map(abs).reduce((acc, x) => acc + x, 0);
}
又或者可以直接reduce
xs.reduce((acc, x) => acc + abs(x), 0)
不過呢d都係用緊higher order function,
想寫hof既話好快會發現d hof已經比人寫哂
Why not define the abs function first? (Maybe I'm wrong and abs is assumed to have been defined or imported from a maths library)
Also why not change to ES2015 (or ES6) style of defining a function? (It's now in 2017 and ES6 has already been in effect for quite a while!!!)
If I were you, I would add/change the code as follows:
e.g. under node:
> abs_sum([1,2,3,-4,-5]);
15
你唔寫class咁用哂lambda梗係冇問題
但係lambda絕對唔係function既short hand,
this is so 伏
用冇問題, 但要記住lambda唔係short hand
算係架已經（最少Java班developer恨左好耐)
只係睇係從咩角度講，lambda提供左first class function 既既environment得你可以寫出FP way
function本身就係js既first class citizen,
同lambda出現根本冇關係
只係好多人成日都當左係shorthand,
又或者當function係過氣嘅寫法
冇留意到佢地semantics係有分別
仲有個case就係variable length argument
function sum() {
return arguments.reduce((arr, x) => arr + x, 0); // 貪方便寫番lambda算
}
const sum = () => {
// arguments 係唔存在架
}
