@@ -156,7 +156,7 @@ result.os.toString();
 
 Or access parts of these properties directly:
 
-```php
+```js
 result.browser.name;
 // Chrome
 
@@ -172,7 +172,7 @@ result.engine.name;
 
 Finally you can also query versions directly:
 
-```php
+```js
 result.browser.version.is('>', 26);
 // true
 
@@ -192,46 +192,56 @@ In some cases you may want to disable the detection of bots. This allows the bot
 ```js
 result = new WhichBrowser(request.headers, { detectBots: false });
 ```
-<!---
 
 Enable result caching
 ---------------------
 
-WhichBrowser supports PSR-6 compatible cache adapters for caching results between requests. Using a cache is especially useful if you use WhichBrowser on every page of your website and a user visits multiple pages. During the first visit the headers will be parsed and the result will be cached. Upon further visits, the cached results will be used, which is much faster than having to parse the headers again and again.
-
-There are adapters available for other types of caches, such as APC, Doctrine, Memcached, MongoDB, Redis and many more. The configuration of these adapters all differ from each other, but once configured, all you have to do is pass it as an option when creating the `Parser` object, or use the `setCache()` function to set it afterwards. WhichBrowser has been tested to work with the adapters provided by [PHP Cache](http://php-cache.readthedocs.org/en/latest/). For a list of other packages that provide adapters see [Packagist](https://packagist.org/providers/psr/cache-implementation).
+WhichBrowser can cache results between requests. Using a cache is especially useful if you use WhichBrowser on every page of your website and a user visits multiple pages. During the first visit the headers will be parsed and the result will be cached. Upon further visits, the cached results will be used, which is much faster than having to parse the headers again and again.
 
-For example, if you want to enable a memcached based cache you need to install an extra composer package:
+In order to enable caching you need to specify in the options object which type of cache you want use.
 
-    composer require cache/memcached-adapter
+For example, if you want to enable the cache you need to construct the `WhichBrowser` object in this way:
 
-And change the call to WhichBrowser/Parser as follows:
+```js
+const result = new WhichBrowser(request.header, {cache: WhichBrowser.SIMPLE_CACHE});
+```
+If a result is retrieved from the cache it has the `cached` property set to `true`
 
-```php
-$client = new \Memcached();
-$client.addServer('localhost', 11211);
+```js
+if (result.cached) {
+  // from cache
+} else {
+  // just parsed for the first time
+}
+```
+You can also specify after how many seconds a cached result should be discarded. The default value is 900 seconds or 15 minutes. If you think WhichBrowser uses too much memory for caching, you should lower this value. You can do this by setting the `cacheExpires` property in the options object.
 
-$pool = new \Cache\Adapter\Memcached\MemcachedCachePool($client);
+For example, if you want that your cached results lasts for 300 seconds or 5 minutes do:
 
-result = new WhichBrowser\Parser(getallheaders(), [ 'cache' => $pool ]);
+```js
+const result = new WhichBrowser(request.header, {
+  cache: WhichBrowser.SIMPLE_CACHE,
+  cacheExpires: 300
+  }
+);
 ```
+A value for `cacheExpires` less or equal to `0` disable the expiry for that result and it will last until you restart node or you parse another UA with a `cacheExpires` greater than `0`.
+This will restart the cache validity check and all the records parsed with `cacheExpires <= 0` will be removed at the next cache validity check.
 
-or
-
-```php
-$client = new \Memcached();
-$client.addServer('localhost', 11211);
+Cache validity is checked at a rate of `cacheExpires / 5` so, with a `cacheExpires` of `500`, you can rest assured that your result has been reaped from the cache after `500 + 500 / 5 + 1` seconds.
 
-$pool = new \Cache\Adapter\Memcached\MemcachedCachePool($client);
+If you want to speed up the process of validity check you can set the `cacheCheckInterval` property in the options object. This property can't be smaller than `1`.
 
-result = new WhichBrowser\Parser();
-result.setCache($pool);
-result.analyse(getallheaders());
+```js
+const result = new WhichBrowser(request.header, {
+  cache: WhichBrowser.SIMPLE_CACHE,
+  cacheCheckInterval: 1
+  }
+);
 ```
+In this way the cache lasts for `900` seconds but is checked every `1` second.
 
-You can also specify after how many seconds a cached result should be discarded. The default value is 900 seconds or 15 minutes. If you think WhichBrowser uses too much memory for caching, you should lower this value. You can do this by setting the `cacheExpires` option or passing it as a second parameter to the `setCache()` function.
-
--->
+> Be aware that changing the `cacheExpiries` *doesn't* impact the expiry date of others records in the cache. However it *will change* the rate at which the cache validity is checked  as it does `cacheCheckInterval`. For example setting `cacheExpiries` to `0` will prevent **ALL** results to expire because it will disable the cache validity check.
 
 API reference
 -------------
 
@@ -20,7 +20,7 @@ class Cache {
   static analyseWithCache(headers, options, that) {
     if (options.cache) {
       const Parser = require('./Parser');
-      options.cacheExpires = options.cacheExpires <= 0 ? 0 : options.cacheExpires || 900;
+      options.cacheExpires = options.cacheExpires <= 0 ? Number.MAX_SAFE_INTEGER : options.cacheExpires || 900;
       options.cacheCheckInterval = Math.max(options.cacheCheckInterval || parseInt(options.cacheExpires / 5, 10), 1);
       switch (options.cache) {
         case Parser.SIMPLE_CACHE: {
@@ -33,10 +33,6 @@ class Cache {
             clearInterval(cacheCleanerInterval);
             cacheCleanerInterval = setInterval(Cache.clearCache, options.cacheCheckInterval * 1000);
           }
-          // Disable cache expiry loop if it set to 0s
-          if (!options.cacheExpires) {
-            clearInterval(cacheCleanerInterval);
-          }
           actualCacheCheckInterval = options.cacheCheckInterval;
           const cacheKey = Crypto.createHash('sha256').update(JSON.stringify(headers)).digest('hex');
           if (simpleCache.has(cacheKey)) {
@@ -85,7 +81,9 @@ class Cache {
    * @return {int}                       The expiration time timestamp
    */
   static getExpirationTime(options) {
-    return +new Date() + options.cacheExpires * 1000;
+    return options.cacheExpires === Number.MAX_SAFE_INTEGER
+      ? Number.MAX_SAFE_INTEGER
+      : +new Date() + options.cacheExpires * 1000;
   }
 
   /**
 
@@ -10,7 +10,9 @@ class Parser extends Main {
    * Create a new object that contains all the detected information
    *
    * @param  {object|string}   headers   Optional, an object with all of the headers or a string with just the User-Agent header
-   * @param  {object}         options   Optional, an object with configuration options
+   * @param  {object}          options   Optional, an object with configuration options
+   * @param  {int}             [options.cacheExpires=900]   Expiry time in seconds
+   * @param  {int}             [options.cacheCheckInterval=1/5 * options.cacheExpires] Time in seconds between each cache check to remove expired records. Minimum 1
    */
   constructor(headers = null, options = {}) {
     super();
 
@@ -322,7 +322,7 @@ describe('Cache Class', () => {
   });
 
   describe('Enable cache expiry when cache has already some item inside with no expiry time,', () => {
-    it('old item are cleared at the first cache check interval ', (done) => {
+    it('Old items are still there when the new expiry time come', (done) => {
       // First call to Parser, still not cached, expiry time default to 900s
       let result = new Parser(header1, {cache: Parser.SIMPLE_CACHE, cacheExpires: 0});
       expect(result.toObject()).to.be.equal(comparision1);
@@ -340,16 +340,16 @@ describe('Cache Class', () => {
       expect(result2.toObject()).to.be.equal(comparision2);
       expect(result2.cached).to.not.exist();
 
-      // let 1/5 of the expiry time so the cache check is triggered
-      clock.tick((900 / 5 + 1) * 1000);
+      // expiry the second record
+      clock.tick((900 + 900 / 5 + 1) * 1000);
 
       result = new Parser(header1, {cache: Parser.SIMPLE_CACHE});
       expect(result.toObject()).to.be.equal(comparision1);
-      expect(result.cached).to.not.exist();
+      expect(result.cached).to.be.true();
 
       result2 = new Parser(header2, {cache: Parser.SIMPLE_CACHE});
       expect(result2.toObject()).to.be.equal(comparision2);
-      expect(result2.cached).to.be.true();
+      expect(result2.cached).to.not.exists();
 
       done();
     });