Underscore.js (hereafter called Underscore) is a JavaScript library supporting functional programming. The Underscore website describes the library as such:
Underscore is a utility-belt library for JavaScript that provides a lot of the functional programming support that you would expect in Prototype.js (or Ruby), but without extending any of the built-in JavaScript objects.
In case you didn’t grow up watching the kitschy old Batman television show, the term “utility belt” means that it provides a set of useful tools that will help you solve many common problems.[1]
The Underscore website has the latest version of the library. You can download the source from the website and import it into the applicable project directories.
Underscore can be added to your own projects in the same way you
would add any other JavaScript library. However, there are a few points
to make about how you interact with Underscore. First, by default
Underscore defines a global object named _ that contains all of its functions. To call
an Underscore function, you simply call it as a method on _, as shown in the following code:
_.times(4, function() { console.log("Major") });
// (console) Major
// (console) Major
// (console) Major
// (console) MajorSimple, no?
One thing that might not be so simple is if you already defined a
global _ variable. In this case,
Underscore provides a _.noConflict
function that will rebind your old _
and return a reference to Underscore itself. Therefore, using _.noConflict works as follows:
var underscore = _.noConflict();
underscore.times(4, function() { console.log("Major") });
// (console) Major
// (console) Major
// (console) Major
// (console) Major
_;
//=> Whatever you originally bound _ toYou’ll see many of the details of Underscore throughout this book, but bear in mind that while I use Underscore extensively (and endorse it), this is not a book about Underscore per se.
Many years ago, I wanted to write a library for JavaScript based on functional programming techniques. Like many programmers, I had obtained a working understanding of JavaScript through a mixture of experimentation, use, and the writing of Douglas Crockford. Although I went on to complete my functional library (which I named Doris), I rarely used it for even my own purposes.
After completing Doris, I went on to other ventures, including extensive work with (and on) the functional programming languages Scala and Clojure. Additionally, I spent a lot of time helping to write ClojureScript, especially its compiler that targets JavaScript. Based on these experiences, I gained a very good understanding of functional programming techniques. As a result, I decided to resurrect Doris and try it again, this time using techniques learned in the intervening years. The product of this effort was called Lemonad, which was developed in conjunction with the content of this book.
While many of the functions in this book are created for the purpose of illustration, I’ve expanded on the lessons in this book in my Lemonad library and the official underscore-contrib library.
The source code for Functional JavaScript is available on GitHub. Additionally, navigating to the book’s website will allow you to use your browser’s JavaScript console to explore the functions defined herein.
Throughout the course of this book (and in general when writing JavaScript) I observe various rules when writing functions, including the following:
Avoid assigning variables more than once.
Do not use
eval.[2]Do not modify core objects like
ArrayandFunction.Favor functions over methods.
If a function is defined at the start of a project, then it should work in subsequent stages as well.
Additionally, I use various conventions in the text of this book, including the following:
Functions of zero parameters are used to denote that the arguments don’t matter.
In some examples,
...is used to denote that the surrounding code segments are being ignored.Text like
inst#methoddenotes a reference to an instance method.Text like
Object.methoddenotes a reference to a type method.I tend to restrict
if/elsestatements to a single line per branch, so I prefer to avoid using curly brackets to wrap the blocks. This saves precious vertical space.I like to use semicolons.
For the most part, the JavaScript code in this book is like the majority of JavaScript code that you’ll see in the wild, except for the functional composition, which is the whole point of writing the book in the first place.
This book started as an idea a few years ago, to write an introductory book on functional programming in the Scheme programming language. Although Scheme and JavaScript have some common features, they are very different in many important ways. However, regardless of the language used, much of functional programming is transcendent. Therefore, I wrote this book to introduce functional programming in the context of what is and what is not possible with JavaScript.
I assume a base-level understanding of JavaScript. There are many amazing books on the topic and a bevy of online resources, so an introduction to the language is not provided herein. I also assume a working understanding of object-oriented programming, as commonly practiced in languages such as Java, Ruby, Python, and even JavaScript. While knowing object-oriented programming can help you to avoid my use of the occasional irrelevant phrase, an expert-level understanding of the subject is not required.
The ideal readers for Functional JavaScript are long-time JavaScript programmers hoping to learn about functional programming, or long-time functional programmers looking to learn JavaScript. For the latter case, it’s advised that this book be supplemented with material focusing on JavaScript’s…oddities. Of particular note is JavaScript: The Good Parts by Douglas Crockford (O’Reilly). Finally, this book is appropriate for anyone looking to learn more about functional programming, even those who have no intention of using JavaScript beyond the confines of these pages.
Here is an outline of the topics covered in Functional JavaScript:
- Chapter 1, Introducing Functional JavaScript
The book starts off by introducing some important topics, including functional programming and Underscore.js.
- Chapter 2, First-Class Functions and Applicative Programming
Chapter 2 defines first-class functions, shows how to use them, and describes some common applications. One particular technique using first-class functions—called applicative programming—is also described. The chapter concludes with a discussion of “data thinking,” an important approach to software development central to functional programming.
- Chapter 3, Variable Scope and Closures
Chapter 3 is a transitional chapter that covers two topics of core importance to understanding functional programming in JavaScript. I start by covering variable scoping, including the flavors used within JavaScript: lexical scoping, dynamic scoping, and function scoping. The chapter concludes with a discussion of closures—how they operate, and how and why you might use them.
- Chapter 4, Higher-Order Functions
Building on the lessons of Chapters 2 and 3, this chapter describes an important type of first-class function: higher-order functions. Although “higher-order functions” sound complicated, this chapter shows that they are instead straightfoward.
- Chapter 5, Function-Building Functions
Moving on from the lessons of the previous chapters, Chapter 5 describes a way to “compose” functions from other functions. Composing functions is an important technique in functional programming, and this chapter will help guide you through the process.
- Chapter 6, Recursion
Chapter 6 is another transitional chapter in which I’ll discuss recursion, a term that describes a function that calls itself either directly or indirectly. Because recursion is limited in JavaScript, it’s not often used; however, there are ways around these limitations, and this chapter will guide you through a few.
- Chapter 7, Purity, Immutability, and Policies for Change
Chapter 7 deals with various ways to write functional code that doesn’t change anything. Put simply, functional programming is facilitated when variables are not changed at all, and this chapter will guide you through just what that means.
- Chapter 8, Flow-Based Programming
Chapter 8 deals with viewing tasks, and even whole systems, as virtual “assembly lines” of functions that transform and move data.
- Chapter 9, Programming Without Class
The final chapter focuses on how functional programming allows you to structure applications in interesting ways that have nothing to do with class-based object-oriented programming.
Following these chapters, the book concludes with two appendixes of supplementary information: Appendix A and Appendix B.
The following typographical conventions are used in this book:
- Italic
Indicates new terms, URLs, email addresses, filenames, and file extensions.
Constant widthUsed for program listings, as well as within paragraphs to refer to program elements such as variable or function names, databases, data types, environment variables, statements, and keywords.
Constant width boldShows commands or other text that should be typed literally by the user.
Constant width italicShows text that should be replaced with user-supplied values or by values determined by context.
This book is here to help you get your job done. In general, if this book includes code examples, you may use the code in your programs and documentation. You do not need to contact us for permission unless you’re reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Selling or distributing a CD-ROM of examples from O’Reilly books does require permission. Answering a question by citing this book and quoting example code does not require permission. Incorporating a significant amount of example code from this book into your product’s documentation does require permission.
We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. For example: “Functional JavaScript by Michael Fogus (O’Reilly). Copyright 2013 Michael Fogus, 978-1-449-36072-6.”
If you feel your use of code examples falls outside fair use or the permission given above, feel free to contact us at [email protected].
Note
Safari Books Online (www.safaribooksonline.com) is an on-demand digital library that delivers expert content in both book and video form from the world’s leading authors in technology and business.
Technology professionals, software developers, web designers, and business and creative professionals use Safari Books Online as their primary resource for research, problem solving, learning, and certification training.
Safari Books Online offers a range of product mixes and pricing programs for organizations, government agencies, and individuals. Subscribers have access to thousands of books, training videos, and prepublication manuscripts in one fully searchable database from publishers like O’Reilly Media, Prentice Hall Professional, Addison-Wesley Professional, Microsoft Press, Sams, Que, Peachpit Press, Focal Press, Cisco Press, John Wiley & Sons, Syngress, Morgan Kaufmann, IBM Redbooks, Packt, Adobe Press, FT Press, Apress, Manning, New Riders, McGraw-Hill, Jones & Bartlett, Course Technology, and dozens more. For more information about Safari Books Online, please visit us online.
Please address comments and questions concerning this book to the publisher:
| O’Reilly Media, Inc. |
| 1005 Gravenstein Highway North |
| Sebastopol, CA 95472 |
| 800-998-9938 (in the United States or Canada) |
| 707-829-0515 (international or local) |
| 707-829-0104 (fax) |
We have a web page for this book, where we list errata, examples, and any additional information. You can access this page at http://oreil.ly/functional_js.
To comment or ask technical questions about this book, send email to [email protected].
For more information about our books, courses, conferences, and news, see our website at http://www.oreilly.com.
Find us on Facebook: http://facebook.com/oreilly
Follow us on Twitter: http://twitter.com/oreillymedia
Watch us on YouTube: http://www.youtube.com/oreillymedia
It takes a village to write a book, and this book is no different. First, I would like to thank my good friend Rob Friesel for taking the time to provide feedback throughout the course of writing this book. Additionally, I would like to thank Jeremy Ashkenas for putting me in touch with O’Reilly and really making this book possible from the start. Plus he wrote the Underscore.js library—no small matter.
The following people have provided great conversation, direct feedback, or even inspiration from afar over the years, and I thank them all just for being awesome: Chris Houser, David Nolen, Stuart Halloway, Tim Ewald, Russ Olsen, Alan Kay, Peter Seibel, Sam Aaron, Brenton Ashworth, Craig Andera, Lynn Grogan, Matthew Flatt, Brian McKenna, Bodil Stokke, Oleg Kiselyov, Dave Herman, Mashaaricda Barmajada ee Mahmud, Patrick Logan, Alan Dipert, Alex Redington, Justin Gehtland, Carin Meier, Phil Bagwell, Steve Vinoski, Reginald Braithwaite, Daniel Friedman, Jamie Kite, William Byrd, Larry Albright, Michael Nygard, Sacha Chua, Daniel Spiewak, Christophe Grand, Sam Aaron, Meikel Brandmeyer, Dean Wampler, Clinton Dreisbach, Matthew Podwysocki, Steve Yegge, David Liebke, and Rich Hickey.
My soundtrack while writing Functional JavaScript was provided by Pantha du Prince, Black Ace, Brian Eno, Béla Bartók, Dieter Moebius, Sun Ra, Broadcast, Scientist, and John Coltrane.
Finally, nothing that I do would be possible without the support of the three loves of my life: Keita, Shota, and Yuki.
[1] Batman actually had more than just useful tools—he had tools for every conceivable circumstance, including those that might require a Bat Alphabet Soup Container or Bat Shark Repellant. Underscore doesn’t quite match that level of applicability.
[2] Like all powerful tools, JavaScript’s eval and Function constructors can be used for
harm as well as for good. I have nothing against them per se,
but I rarely need them.