In this section, we will introduce another concept to the pattern that we've created: 

**Operators**.

Operators are the final big piece that allows us to bend all asynchronous behaviors to our will. They give us a chance to redefine broadcasters and listeners in any way we want. 

We'll several operators throughout this section to implement mapping, filtering, and piping behaviors (and more!).

By the end, you'll get a real sense of how you can continue building on top of the functionality you've already built.

**You're in Section 03 of [Composing Closures and Callbacks in JavaScript](https://egghead.io/playlists/composing-closures-and-callbacks-in-javascript-1223)**

Let's add another layer of wrapping so that we can override the behavior of broadcasters. Operators are the final big piece that allows us to bend all asynchronous behaviors to our will. The give us a chance to redefine broadcasters and listeners in any way we want. 

Create an Operator Function to Modify Behaviors

Changing a value into something else is a fundamental concept of programming. When dealing with async code, we want to catch the value inside a function and apply a transformation to it. We do this with a map operator.

Transform Values with a Map Operator

Conditional behavior is another fundamental concept of programming. It's like writing an if statement for async code. A filter operator allows us to only allow through the values that meet our criteria.

Prevent Certain Values with a Filter Operator

Rather than continuing to pass functions to functions, we can leveraging a pipe utility to write our functions out in a sequenced list. This makes our code much easier to understand and refactor while expressing the intent of "do this, then this, then that".

Use Pipe to Clean Up Functions Wrapping Functions

If you can think ahead to how you want your code to look into the future, then you can tackle your problems from the inside out. You design how you want the code to look, then go about implementing the internals. This is similar to a "test driven development" mindset where you test the implementation first, then write the actual implementation of the function after.

Start With the API You Want Then Implement

If you find yourself repeating a lot of the same code over and over, this might be an opportunity to write a utility function to capture the repetition and keep it tucked away in a single function. This lesson walks through writing a createOperator utility to capture the repetition of the "done" logic in each operator.

Define a Function to Set Common Behaviors in Operators

Buffers give you chance to gather values together until your ready to work with them. This pattern can be used for calculations, string manipulations, and many other scenarios. 

Consider a solution where splitter argument is a function instead of a value. How could you capture the condition in that function rather than the way it was implemented in this lesson

## Congrats on finishing Section 03: Use the Callback and Closure Pattern to Build Advanced Async Behaviors!🎉🎉

  👉  **[CLICK HERE to continue to the next section, Implement the Pattern in Common Async Scenarios.](https://egghead.io/playlists/implement-the-pattern-in-common-async-scenarios-c059)** 👈 

Use the Callback and Closure Pattern to Build Advanced Async Behaviors

Instructor

Course Content