minor optimizations, code comments

Author: jonschlinkert

index.js

@@ -7,30 +7,45 @@
 
 'use strict';
 
-module.exports = function regexCache(fn, str, options, nocompare) {
+/**
+ * Expose `regexCache`
+ */
+
+module.exports = regexCache;
+
+/**
+ * Memoize the results of a call to the new RegExp constructor.
+ *
+ * @param  {Function} fn [description]
+ * @param  {String} str [description]
+ * @param  {Options} options [description]
+ * @param  {Boolean} nocompare [description]
+ * @return {RegExp}
+ */
+
+function regexCache(fn, str, options, nocompare) {
   var regex, cached;
-  if (arguments.length === 1) {
+
+  // `str` might be explicitly defined as `null`
+  if (str === null || arguments.length === 1) {
+    str = '_default_';
     nocompare = true;
     options = null;
     str = null;
   }
 
-  if (str === null) {
-    str = '__default';
-  }
-
   if (cache.hasOwnProperty(str)) {
     cached = cache[str];
-    if (nocompare) {
-      return cached.regex;
-    }
+    // return early without comparing options
+    if (nocompare) { return cached.regex; }
 
+    // otherwise, compare options first
     if (equal(cached.opts, options)) {
       return cached.regex;
     }
   }
 
-  if (str === '__default') {
+  if (str === '_default_') {
     regex = fn(options);
   } else {
     regex = fn(str, options);
@@ -40,20 +55,30 @@ module.exports = function regexCache(fn, str, options, nocompare) {
   return regex;
 };
 
+/**
+ * Cache a `str` with the given `opts` and
+ * generated `regex`.
+ *
+ * @param  {String} `str`
+ * @param  {Object} `opts`
+ * @param  {RegExp} `regex`
+ */
+
 function memo(str, opts, regex) {
   cache[str] = {regex: regex, opts: opts};
 }
 
 var cache = module.exports.cache = {};
 
 /**
- * Return false if object A is different (enough)
- * from object B.
+ * Return false if object A is different (enough) from object B.
+ *
+ * When creating the regex, memoization is used to increase
+ * performance. This function tells us if options have changed
+ * so we can generate a new regex instead of using the cached one.
  *
- * When creating the regex memoization is used
- * to increase performance. This function tells
- * us if options have changed so we can generate
- * a new regex instead of using the cached one.
+ * It seems like a lot of logic but in most cases this function
+ * returns early.
  *
  * @param {Object} `a` cached options
  * @param {Object} `b` passed options