Bacon.js Cheat Sheet by ProLoser

maps values using given function, returning a new EventS­tream. Instead of a function, you can also provide a constant value. Further, you can use a property extractor string like ".ke­yCo­de". So, if f is a string starting with a dot, the elements will be mapped to the corres­ponding field/­fun­ction in the event value. For instance map(".k­eyC­ode­") will pluck the keyCode field from the input values. If keyCode was a function, the result stream would contain the values returned by the function. The Function Constr­uction rules below apply here.

maps errors using given function. More specif­ically, feeds the "­err­or" field of the error event to the function and produces a "­Nex­t" event based on the return value. Function Constr­uction rules apply. You can omit the argument to produce a Next event with undefined value.

filters values using given predicate function. Instead of a function, you can use a constant value (true/­false) or a property extractor string (like ".is­Val­uab­le") instead. Just like with map, indeed.

takes while given predicate function holds true

takes elements from source until a Next event appears in the other stream. If other stream ends without value, it is ignored

delays the stream­/pr­operty by given amount of millis­econds. Does not delay the initial value of a Property.

throttles stream­/pr­operty by given amount of millis­econds, but so that event is only emitted after the given "­quiet period­". Does not affect emitting the initial value of a Property. The difference of throttle and debounce is the same as it is in the same methods in jQuery.

returns a stream­/pr­operty where the function f is executed for each value, before dispat­ching to subscr­ibers. This is useful for debugging, but also for stuff like calling the preven­tDe­fault() method for events. In fact, you can also use a proper­ty-­ext­ractor string instead of a function, as in ".pr­eve­ntD­efa­ult­".

for each element in the source stream, spawn a new stream using the function f. Collect events from each of the spawned streams into the result EventS­tream. This is very similar to selectMany in RxJs. Note that instead of a function, you can provide a stream­/pr­operty too. Also, the return value of function f can be either an Observable (strea­m/p­rop­erty) or a constant value. The result of flatMap is always an EventS­tream. stream.fl­atMap() can be used conven­iently with Bacon.o­nce() and Bacon.n­ever() for converting and filtering at the same time, including only some of the results.

like flatMap, but doesn't spawns a new stream only if the previously spawned stream has ended.

is like scan but only emits the final value, i.e. the value just before the observable ends. Returns a Property.

returns a Property that represents the result of a comparison between the previous and current value of the Observ­able. For the initial value of the Observ­able, the previous value will be the given start.

returns a Property that represents a "­sliding window­" into the history of the values of the Observ­able. The result Property will have a value that is an array containing the last n values of the original observ­able, where n is at most the value of the max argument, and at least the value of the min argument. If the min argument is omitted, there's no lower limit of values.

combines the latest values of the two streams or properties using a two-arg function. Similarly to scan, you can use a method name instead, so you could do a.comb­ine(b, ".co­nca­t") for two properties with array value. The result is a Property.

decodes input using the given mapping. Is a bit like a switch­-case or the decode function in Oracle SQL. For example, the following would map the value 1 into the the string "­mik­e" and the value 2 into the value of the who property.

a stream of events

like onValue, but splits the value (assuming its an array) as function arguments to f

subscribes given handler function to event stream. Function will receive Event objects (see below). The subscr­ibe() call returns a unsubs­cribe function that you can call to unsubs­cribe. You can also unsubs­cribe by returning Bacon.n­oMore from the handler function as a reply to an Event.

concat­enates two streams into one stream so that it will deliver events from stream1 until it ends and then deliver events from stream2. This means too that events from stream2, occurring before the end of stream1 will not be included in the result stream.

buffers stream events with given delay. The buffer is flushed at most once in the given delay. So, if your input contains [1,2,3­,4,­5,6,7], then you might get two events containing [1,2,3,4] and [5,6,7] respec­tively, given that the flush occurs between numbers 4 and 5.

buffers stream events with given count. The buffer is flushed when it contains the given number of elements. So, if you buffer a stream of [1, 2, 3, 4, 5] with count 2, you'll get output events with values [1, 2], [3, 4] and [5].

creates a Property based on the EventS­tream. Without arguments, you'll get a Property without an initial value. The Property will get its first actual value from the stream, and after that it'll always have a current value.

creates a Property that indicates whether stream1 is awaiting stream2, i.e. has produced a value after the latest value from stream2. This is handy for keeping track whether we are currently awaiting an AJAX response: var showAj­axI­ndi­cator = ajaxRe­que­st.a­wa­iti­ng(­aja­xRe­sponse)

returns a new Bus.

ends the stream. Sends an End event to all subscr­ibers. After this call, there'll be no more events to the subscr­ibers. Also, the Bus push and plug methods have no effect.

plugs the given stream to the Bus. All events from the given stream will be delivered to the subscr­ibers of the Bus. Returns a function that can be used to unplug the same stream. The plug method practi­cally allows you to merge in other streams after the creation of the Bus. I've found Bus quite useful as an event broadcast mechanism in the Worzone game, for instance.

a reactive property. Has the concept of "­current value". You can create a Property from an EventS­tream by using either toProperty or scan method. Note depending on how a Property is created, it may or may not have an initial value.

subscribes a handler function to property. If there's a current value, an Initial event will be pushed immedi­ately. Next event will be pushed on updates and an End event in case the source EventS­tream ends.

like onValue, but splits the value (assuming its an array) as function arguments to f

calls the method of the given object with each value of this Property. You can optionally supply arguments which will be used as the first arguments of the method call. For instance, if you want to assign your Property to the "­dis­abl­ed" attribute of a JQuery object, you can do this: myProp­ert­y.a­ssi­gn(­$("#­my-­but­ton­"), "­att­r", "­dis­abl­ed") A simpler example would be to toggle the visibility of an element based on a Property: myProp­ert­y.a­ssi­gn(­$("#­my-­but­ton­"), "­tog­gle­") Note that the assign method is actually just a synonym for onValue and the function constr­uction rules below apply to both.

creates an EventS­tream by sampling the property value at each event from the given stream. The result EventS­tream will contain the property value at each event in the source stream.

samples the property on stream events. The result values will be formed using the given function f(prop­ert­yValue, sample­rVa­lue). You can use a method name (such as ".co­nca­t") instead of a function too.

returns an EventS­tream of property value changes. Returns exactly the same events as the property itself, except any Initial events. Note that proper­ty.c­ha­nges() does NOT skip duplicate values, use .skipD­upl­ica­tes() for that.

combines properties with the || operator.

has subclasses Next, End, Error and Initial

an end-of­-stream event of EventS­tream or Property. Call isEnd() to distin­guish an End from other events.

the initial (current) value of a Property. Call isInit­ial() to distin­guish from other events. Only sent immedi­ately after subscr­iption to a Property.

returns the value associated with a Next or Initial event

true for Next events

true for End events