určitě je lepší než napsat:
red_cars = map(lambda x: x.color = 'red', filter(lambda x: x.id == 'ID2376', cars))
je lepší napsat
def set_color(color):
return lambda x: x.color = color
def where_id(id):
return lambda x: x.id == id
car.id = 'ID2376'
red_cars = map(set_color('red'), filter(where_id(car), cars)
protože pak můžete v budoucnosti vylepšit vyhledávání pomocí regulárního výrazu, nebo strukturovat data různých entit a typů podle jednotné šablony, obsahující id, barvu a podobně.
Ufff... Já se jenom zeptám: jaké funkcionální jazyky umíš a kolik jsi toho v nich naprogramoval? Nemůžu se totiž ubránit dojmu, že si myslíš, že JS je funkcionální jazyk a je hnusný, protože se v něm používají funkcionální patterny. Jediný, co z toho je pravda, je, že JS je hnusný jazyk. A shodnou se na tom úplně všichni.
Myslím si to, protože 1. mluvíš o objektech, které se ve FP nepoužívají, 2. v JS jsou samozřejmě lambdy nadužívané, ale má to jiný důvod než snahu o FP
Ten hlavní důvod, proč se v JS lambdy nadužívají, je, že neumí synchronizovat asynchronní události. Takže v JS musím napsat:
function set_user_val(callback) {
async_get_data(function(data){
some_other_async(data,callback)
})
}
set_user_val(function(data){
$('#user-val').value(data['user_val'])
})
...a ES6 to vylepší jenom tím, že nemusím psát "function", ale jinak ten kód zůstane stejně pitomě vnořený a plný lambd. V pořádném funkcionálním jazyce, který umí synchronizovat asynchronní události by to mohlo vypadat třeba takhle (Elixir):
def get_data do
send(Agent1, :get_data)
data = receive do
{:get_data_response,data} -> data #### TADY
after 5000 -> raise "Timeout"
end
end
data = get_data |> some_other_async
set_value('#user-val',data)
end
...a nepotřeboval jsem jedinou lambdu. Na řádku "TADY" dochází k tomu, že funkce normálně synchronně vrací hodnotu, kterou získala asynchronně. To v JS nejde a proto je potřeba donekonečna vnořovat callbacky nebo aspoň řetězit berličky typu
.done(()=>{...}).fail(()=>{...})
Jinak, i ten filtr je v Elixiru daleko čitelnější:
red_cars = cars |> Enum.filter(fn x -> x[:id]==XXXX end) |> Enum.map(fn x -> x[:color]=:red end)
nebo ještě zhuštěněji:
red_cars = cars |> Enum.filter(&(&1[:id]==XXXX)) |> Enum.map(&(&1[:color]=:red))
Zobrazit příspěvky
