Functions and higher-order code
This part of the JavaScript course follows a call: it binds arguments to parameters by position, a default or a rest parameter changes what is bound, and an options object replaces a long list with names. Then functions become values: a pure function is tested by its return value, a callback is code run later, and map, filter and reduce are written by hand before they are used. Currying, composition and memoization build one function out of others, recursion, generators and the iterator protocol supply the lazy forms, and the part ends with a validator built from these pieces.
035
Parameters and arguments: what a call passes
parameters bound by position, a missing argument as undefined, an extra one dropped, the arguments object of an old function, a rest parameter that collects an array
Open
036
Default parameters: when they are evaluated
a default for an undefined argument, the expression evaluated per call, a default that reads an earlier parameter, null and the temporal dead zone of a later one
Open
037
Options objects: arguments by name
the long positional list, one object destructured in the parameter list with defaults, an omitted object, unknown keys and the rest of them, a required option that throws
Open
038
Pure functions: same input, same output
determinism against a counter of the module, a call that changes its argument, a table of test cases with no setup, an impure shell around a pure core
Open
039
Functions as values: store, pass, return
a function in a binding, an array and an object, a function passed as an argument, a factory that returns one, an object of functions as a dispatch table
Open
040
Callbacks: passing code to be run later
a callback called once per item, the error-first convention with an early return, the nesting of three dependent steps, a retry that calls itself
Open
041
map, filter and reduce written by hand
each method as a for loop, the value, index and array of the callback, the accumulator and the missing initial value, the chain that reads in order
Open
042
Currying and partial application
one argument at a time through closures, fixed arguments with bind and with a wrapper, a curry built on fn.length, the arity trap of a default or rest parameter
Open
043
Composition: pipe and compose
a pipeline as a reduce over functions, compose in the other direction, an order that changes the result, a pipeline built at run time from an options object
Open
044
Memoization: a cache with Map
a Map from arguments to results, a memoize wrapper keyed on the argument list, the functions that must not be cached, an object key and a stale entry
Open
045
Recursion: the base case and the call stack
a function that calls itself, the frame per level, the RangeError of a missing base case, a walk over a tree of nodes
Open
046
Generators: function*, yield and next
yield and the value and done fields, for...of and the spread over a lazy sequence, a value passed into next, an early return and yield* delegation
Open
047
Iterators and iterables: the for-of protocol
an iterator written by hand, Symbol.iterator and the four consumers, an iterable against a used-up iterator, a class that yields its values
Open
048
Putting functions together: a validator library
rules as factories that return null or a message, a schema checked with an options object, a pure normalise step, the report counted with map, filter and reduce
Open