Merge pull request #9 from yusufshakeel/dev

v1.6.0

Author: yusufshakeel

README.md

@@ -5,7 +5,7 @@ Cache data using JavaScript in the browser.
 ### Status
 
 [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/yusufshakeel/dyCacheJS)
-[![npm version](https://img.shields.io/badge/npm-1.5.0-blue.svg)](https://www.npmjs.com/package/dycachejs)
+[![npm version](https://img.shields.io/badge/npm-1.6.0-blue.svg)](https://www.npmjs.com/package/dycachejs)
 [![Build Status](https://travis-ci.org/yusufshakeel/dyCacheJS.svg?branch=master)](https://travis-ci.org/yusufshakeel/dyCacheJS)
 [![](https://data.jsdelivr.com/v1/package/npm/dycachejs/badge)](https://www.jsdelivr.com/package/npm/dycachejs)
 

dist/js/dyCache.min.js

@@ -97,6 +97,7 @@ <h3 class="text-center">Content</h3>
                 <li><a href="#object-methods">Object Methods</a></li>
                 <li><a href="#stack-methods">Stack Methods</a></li>
                 <li><a href="#queue-methods">Queue Methods</a></li>
+                <li><a href="#lru-methods">LRU Methods</a></li>
             </ul>
 
             <hr>
@@ -952,7 +953,7 @@ <h4><code>stackInit(key)</code></h4>
             <h4><code>stackExists(key)</code></h4>
 
             <p>This will check if the stack referred by <code>key</code>
-               exists in the cache.</p>
+                exists in the cache.</p>
 
             <p>Return <code>true</code> if stack exists. Otherwise, <code>false</code>.</p>
 
@@ -1426,6 +1427,105 @@ <h4><code>queueDelete(key)</code></h4>
 
             <hr>
 
+            <a name="lru-methods"></a>
+            <h4 class="text-center"><a href="#lru-methods">LRU Methods</a></h4>
+
+            <p class="text-center">LRU - Least Recently Used</p>
+
+            <br>
+
+            <!-- LRUInit() -->
+            <a name="LRUInit"></a>
+            <h4><code>LRUInit(name, size)</code></h4>
+
+            <p>This will create a new object for the LRU in the cache by the name <code>name</code>
+                having the given <code>size</code>.</p>
+
+            <p>If object referred by <code>name</code> exists in the cache then it will be overwritten.</p>
+
+            <p>If <code>size</code> is not set then LRU object of queue size 3 is created.</p>
+
+            <pre><code>obj.LRUInit('myLRU', 3);    // creates a new LRU object myLRU</code></pre>
+
+            <div>
+                <a class="btn btn-primary"
+                   role="button"
+                   data-toggle="collapse"
+                   href="#collapse-LRUInit"
+                   aria-expanded="false"
+                   aria-controls="collapse-LRUInit">Output</a>
+            </div>
+            <div class="collapse" id="collapse-LRUInit">
+            </div>
+
+            <!-- LRUInit() ends here -->
+
+            <hr>
+
+            <!-- LRUSet() -->
+            <a name="LRUSet"></a>
+            <h4><code>LRUSet(name, key, value)</code></h4>
+
+            <p>This will set <code>key</code>-<code>value</code> pair in the LRU object referred
+                by <code>name</code> in the cache.</p>
+
+            <p><code>key</code> can be a string or number.</p>
+
+            <p><code>value</code> can be a number, string, array or object.</p>
+
+            <p>Returns <code>true</code> on success</p>
+
+            <p>Returns <code>false</code> if LRU object does not exists in the cache.</p>
+
+            <pre><code>obj.LRUSet('myLRU', "k1", 10);    // k1: 10
+obj.LRUSet('myLRU', "k2", 20);    // k2: 20
+obj.LRUSet('myLRU', "k3", 30);    // k3: 30</code></pre>
+
+            <div>
+                <a class="btn btn-primary"
+                   role="button"
+                   data-toggle="collapse"
+                   href="#collapse-LRUSet"
+                   aria-expanded="false"
+                   aria-controls="collapse-LRUSet">Output</a>
+            </div>
+            <div class="collapse" id="collapse-LRUSet">
+            </div>
+
+            <!-- LRUSet() ends here -->
+
+            <hr>
+
+            <!-- LRUGet() -->
+            <a name="LRUGet"></a>
+            <h4><code>LRUGet(name, key)</code></h4>
+
+            <p>This will fetch key-value pair for the given <code>key</code> from the LRU object
+                referred by <code>name</code> in the cache.</p>
+
+            <p>Returns <code>{ key: value }</code> on success.</p>
+
+            <p>Returns <code>{}</code> if <code>key</code> is not found in the LRU object.</p>
+
+            <p>Returns <code>false</code> if the LRU object does not exists in the cache.</p>
+
+            <pre><code>obj.LRUGet('myLRU', "k1");</code></pre>
+
+            <div>
+                <a class="btn btn-primary"
+                   role="button"
+                   data-toggle="collapse"
+                   href="#collapse-LRUGet"
+                   aria-expanded="false"
+                   aria-controls="collapse-LRUGet">Output</a>
+            </div>
+            <div class="collapse" id="collapse-LRUGet">
+            </div>
+
+            <!-- LRUGet() ends here -->
+
+            <hr>
+
 
         </div>
 

index.html

@@ -1,6 +1,6 @@
 {
   "name": "dycachejs",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Cache data using JavaScript in the browser.",
   "main": "index.html",
   "scripts": {

package.json

@@ -726,6 +726,94 @@ var dyCache = /** @class */ (function () {
         }
         return null;
     };
+    /**
+     * This will initialise a LRU (Least Recently Used) new object in the cache
+     * and will refer it by 'name' and will also set the 'size' of the LRU cache.
+     *
+     * If size is not set then a LRU cache of size 3 is created.
+     *
+     * @param {string} name
+     * @param {number} size
+     * @constructor
+     */
+    dyCache.prototype.LRUInit = function (name, size) {
+        if (size === void 0) { size = 3; }
+        this._cache[name] = {
+            _size: size,
+            _data: {},
+            _queue: []
+        };
+    };
+    /**
+     * This will insert key-value pair in the LRU data referred by 'name' in the
+     * cache.
+     *
+     * Return true on successful insert of key-value pair in the LRU, false otherwise.
+     *
+     * @param {string} name
+     * @param key
+     * @param value
+     * @returns {boolean}
+     * @constructor
+     */
+    dyCache.prototype.LRUSet = function (name, key, value) {
+        // if LRU doesn't exists
+        if (!this.exists(name)) {
+            return false;
+        }
+        // if queue has space
+        if (this._cache[name]._size > this._cache[name]._queue.length) {
+            // add new key-value pair in the data set
+            this._cache[name]._data[key] = value;
+            // and insert the key in the queue
+            this._cache[name]._queue.unshift(key);
+        }
+        else {
+            // remove the least recently used key from the back of the queue
+            var removedKey = this._cache[name]._queue.pop();
+            // remove the least recently used key-value pair from the data set
+            delete this._cache[name]._data[removedKey];
+            // now insert the new key-value in the data set
+            this._cache[name]._data[key] = value;
+            // and insert the new key in the queue
+            this._cache[name]._queue.unshift(key);
+        }
+        return true;
+    };
+    /**
+     * This will fetch the cached data in the LRU.
+     *
+     * If key exists in the LRU then it is returned in { key: value } form.
+     * Otherwise, {} is returned.
+     *
+     * false is returned if the LRU doesn't exists.
+     *
+     * @param {string} name
+     * @param key
+     * @returns {any}
+     * @constructor
+     */
+    dyCache.prototype.LRUGet = function (name, key) {
+        // if LRU doesn't exists
+        if (!this.exists(name)) {
+            return false;
+        }
+        // if key found
+        if (this._cache[name]._queue.indexOf(key) > -1) {
+            // remove the key from the queue from its current index
+            this._cache[name]._queue.splice(this._cache[name]._queue.indexOf(key), 1);
+            // now add the key at the front of the queue
+            this._cache[name]._queue.unshift(key);
+            // now prepare the value
+            var data = {};
+            data[key] = this._cache[name]._data[key];
+            // and return the key-value pair in { key: value } form
+            return data;
+        }
+        else {
+            return {};
+        }
+    };
     return dyCache;
 }());