1. module node-cache
   1. boolean node-cache.usingDomains
   2. function node-cache (options)
   3. function node-cache.EventEmitter ()
   4. function node-cache.init ()
   5. function node-cache.listenerCount (emitter, type)
   6. function node-cache.node_cache (options)
   7. number node-cache.defaultMaxListeners
   8. object node-cache.__super__
   9. object node-cache.node_cache.prototype
   10. string node-cache.version
2. module node-cache.node_cache
   1. boolean node-cache.node_cache.usingDomains
   2. function node-cache.node_cache (options)
   3. function node-cache.node_cache.EventEmitter ()
   4. function node-cache.node_cache.init ()
   5. function node-cache.node_cache.listenerCount (emitter, type)
   6. number node-cache.node_cache.defaultMaxListeners
   7. object node-cache.node_cache.__super__
   8. string node-cache.node_cache.version
3. module node-cache.node_cache.prototype
   1. function node-cache.node_cache.prototype._check (key, data)
   2. function node-cache.node_cache.prototype._checkData (startPeriod)
   3. function node-cache.node_cache.prototype._error (type, data, cb)
   4. function node-cache.node_cache.prototype._getKeyLength (key)
   5. function node-cache.node_cache.prototype._getValLength (value)
   6. function node-cache.node_cache.prototype._initErrors ()
   7. function node-cache.node_cache.prototype._isInvalidKey (key)
   8. function node-cache.node_cache.prototype._killCheckPeriod ()
   9. function node-cache.node_cache.prototype._unwrap (value, asClone)
   10. function node-cache.node_cache.prototype._wrap (value, ttl, asClone)
   11. function node-cache.node_cache.prototype.close ()
   12. function node-cache.node_cache.prototype.constructor (options)
   13. function node-cache.node_cache.prototype.del (keys, cb)
   14. function node-cache.node_cache.prototype.flushAll (_startPeriod)
   15. function node-cache.node_cache.prototype.get (key, cb, errorOnMissing)
   16. function node-cache.node_cache.prototype.getStats ()
   17. function node-cache.node_cache.prototype.getTtl (key, cb)
   18. function node-cache.node_cache.prototype.keys (cb)
   19. function node-cache.node_cache.prototype.mget (keys, cb)
   20. function node-cache.node_cache.prototype.set (key, value, ttl, cb)
   21. function node-cache.node_cache.prototype.ttl ()
   22. object node-cache.node_cache.prototype._ERRORS

module node-cache

function node-cache (options)

• description and source-code

  function NodeCache(options) {
    this.options = options != null ? options : {};
    this._initErrors = bind(this._initErrors, this);
    this._error = bind(this._error, this);
    this._getValLength = bind(this._getValLength, this);
    this._wrap = bind(this._wrap, this);
    this._isInvalidKey = bind(this._isInvalidKey, this);
    this._check = bind(this._check, this);
    this._checkData = bind(this._checkData, this);
    this.close = bind(this.close, this);
    this.flushAll = bind(this.flushAll, this);
    this.getStats = bind(this.getStats, this);
    this.keys = bind(this.keys, this);
    this.getTtl = bind(this.getTtl, this);
    this.ttl = bind(this.ttl, this);
    this.del = bind(this.del, this);
    this.set = bind(this.set, this);
    this.mget = bind(this.mget, this);
    this.get = bind(this.get, this);
    this._initErrors();
    this.data = {};
    this.options = _assignIn({
      forceString: false,
      objectValueSize: 80,
      arrayValueSize: 40,
      stdTTL: 0,
      checkperiod: 600,
      useClones: true,
      errorOnMissing: false
    }, this.options);
    this.stats = {
      hits: 0,
      misses: 0,
      keys: 0,
      ksize: 0,
      vsize: 0
    };
    this.validKeyTypes = ["string", "number"];
    this._checkData();
    return;
  }

• example usage

  n/a

function node-cache.EventEmitter ()

• description and source-code

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

• example usage

  n/a

function node-cache.init ()

• description and source-code

  init = function () {
    this.domain = null;
    if (EventEmitter.usingDomains) {
      // if there is an active domain, then attach to it.
      domain = domain || require('domain');
      if (domain.active && !(this instanceof domain.Domain)) {
        this.domain = domain.active;
      }
    }
  
    if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
      this._events = new EventHandlers();
      this._eventsCount = 0;
    }
  
    this._maxListeners = this._maxListeners || undefined;
  }

• example usage

  n/a

function node-cache.listenerCount (emitter, type)

• description and source-code

  listenerCount = function (emitter, type) {
    if (typeof emitter.listenerCount === 'function') {
      return emitter.listenerCount(type);
    } else {
      return listenerCount.call(emitter, type);
    }
  }

• example usage

  n/a

function node-cache.node_cache (options)

• description and source-code

  function NodeCache(options) {
    this.options = options != null ? options : {};
    this._initErrors = bind(this._initErrors, this);
    this._error = bind(this._error, this);
    this._getValLength = bind(this._getValLength, this);
    this._wrap = bind(this._wrap, this);
    this._isInvalidKey = bind(this._isInvalidKey, this);
    this._check = bind(this._check, this);
    this._checkData = bind(this._checkData, this);
    this.close = bind(this.close, this);
    this.flushAll = bind(this.flushAll, this);
    this.getStats = bind(this.getStats, this);
    this.keys = bind(this.keys, this);
    this.getTtl = bind(this.getTtl, this);
    this.ttl = bind(this.ttl, this);
    this.del = bind(this.del, this);
    this.set = bind(this.set, this);
    this.mget = bind(this.mget, this);
    this.get = bind(this.get, this);
    this._initErrors();
    this.data = {};
    this.options = _assignIn({
      forceString: false,
      objectValueSize: 80,
      arrayValueSize: 40,
      stdTTL: 0,
      checkperiod: 600,
      useClones: true,
      errorOnMissing: false
    }, this.options);
    this.stats = {
      hits: 0,
      misses: 0,
      keys: 0,
      ksize: 0,
      vsize: 0
    };
    this.validKeyTypes = ["string", "number"];
    this._checkData();
    return;
  }

• example usage

  n/a

module node-cache.node_cache

function node-cache.node_cache (options)

• description and source-code

  function NodeCache(options) {
    this.options = options != null ? options : {};
    this._initErrors = bind(this._initErrors, this);
    this._error = bind(this._error, this);
    this._getValLength = bind(this._getValLength, this);
    this._wrap = bind(this._wrap, this);
    this._isInvalidKey = bind(this._isInvalidKey, this);
    this._check = bind(this._check, this);
    this._checkData = bind(this._checkData, this);
    this.close = bind(this.close, this);
    this.flushAll = bind(this.flushAll, this);
    this.getStats = bind(this.getStats, this);
    this.keys = bind(this.keys, this);
    this.getTtl = bind(this.getTtl, this);
    this.ttl = bind(this.ttl, this);
    this.del = bind(this.del, this);
    this.set = bind(this.set, this);
    this.mget = bind(this.mget, this);
    this.get = bind(this.get, this);
    this._initErrors();
    this.data = {};
    this.options = _assignIn({
      forceString: false,
      objectValueSize: 80,
      arrayValueSize: 40,
      stdTTL: 0,
      checkperiod: 600,
      useClones: true,
      errorOnMissing: false
    }, this.options);
    this.stats = {
      hits: 0,
      misses: 0,
      keys: 0,
      ksize: 0,
      vsize: 0
    };
    this.validKeyTypes = ["string", "number"];
    this._checkData();
    return;
  }

• example usage

  n/a

function node-cache.node_cache.EventEmitter ()

• description and source-code

  function EventEmitter() {
    EventEmitter.init.call(this);
  }

• example usage

  n/a

function node-cache.node_cache.init ()

• description and source-code

  init = function () {
    this.domain = null;
    if (EventEmitter.usingDomains) {
      // if there is an active domain, then attach to it.
      domain = domain || require('domain');
      if (domain.active && !(this instanceof domain.Domain)) {
        this.domain = domain.active;
      }
    }
  
    if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
      this._events = new EventHandlers();
      this._eventsCount = 0;
    }
  
    this._maxListeners = this._maxListeners || undefined;
  }

• example usage

  n/a

function node-cache.node_cache.listenerCount (emitter, type)

• description and source-code

  listenerCount = function (emitter, type) {
    if (typeof emitter.listenerCount === 'function') {
      return emitter.listenerCount(type);
    } else {
      return listenerCount.call(emitter, type);
    }
  }

• example usage

  n/a

module node-cache.node_cache.prototype

function node-cache.node_cache.prototype._check (key, data)

• description and source-code

  _check = function (key, data) {
    if (data.t !== 0 && data.t < Date.now()) {
      this.del(key);
      this.emit("expired", key, this._unwrap(data));
      return false;
    } else {
      return true;
    }
  }

• example usage

  ...
    if (cb != null) {
      cb(err);
      return;
    } else {
      throw err;
    }
  }
  if ((this.data[key] != null) && this._check(key, this.data[key])) {
    this.stats.hits++;
    _ret = this._unwrap(this.data[key]);
    if (cb != null) {
      cb(null, _ret);
    }
    return _ret;
  } else {
  ...

function node-cache.node_cache.prototype._checkData (startPeriod)

• description and source-code

  _checkData = function (startPeriod) {
    var key, ref, value;
    if (startPeriod == null) {
      startPeriod = true;
    }
    ref = this.data;
    for (key in ref) {
      value = ref[key];
      this._check(key, value);
    }
    if (startPeriod && this.options.checkperiod > 0) {
      this.checkTimeout = setTimeout(this._checkData, this.options.checkperiod * 1000, startPeriod);
      if (this.checkTimeout.unref != null) {
        this.checkTimeout.unref();
      }
    }
  }

• example usage

  ...
      hits: 0,
      misses: 0,
      keys: 0,
      ksize: 0,
      vsize: 0
    };
    this.validKeyTypes = ["string", "number"];
    this._checkData();
    return;
  }
  
  NodeCache.prototype.get = function(key, cb, errorOnMissing) {
    var _err, _ret, err;
    if (typeof cb === "boolean" && arguments.length === 2) {
      errorOnMissing = cb;
  ...

function node-cache.node_cache.prototype._error (type, data, cb)

• description and source-code

  _error = function (type, data, cb) {
    var error;
    if (data == null) {
      data = {};
    }
    error = new Error();
    error.name = type;
    error.errorcode = type;
    error.message = this.ERRORS[type] != null ? this.ERRORS[type](data) : "-";
    error.data = data;
    if (cb && _isFunction(cb)) {
      cb(error, null);
    } else {
      return error;
    }
  }

• example usage

  ...
    if (cb != null) {
      cb(null, _ret);
    }
    return _ret;
  } else {
    this.stats.misses++;
    if (this.options.errorOnMissing || errorOnMissing) {
      _err = this._error("ENOTFOUND", {
        key: key
      }, cb);
      if (_err != null) {
        throw _err;
      }
      return;
    } else {
  ...

function node-cache.node_cache.prototype._getKeyLength (key)

• description and source-code

  _getKeyLength = function (key) {
    return key.length;
  }

• example usage

  ...
  if (this.data[key]) {
    existent = true;
    this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
  }
  this.data[key] = this._wrap(value, ttl);
  this.stats.vsize += this._getValLength(value);
  if (!existent) {
    this.stats.ksize += this._getKeyLength(key);
    this.stats.keys++;
  }
  this.emit("set", key, value);
  if (cb != null) {
    cb(null, true);
  }
  return true;
  ...

function node-cache.node_cache.prototype._getValLength (value)

• description and source-code

  _getValLength = function (value) {
    if (_isString(value)) {
      return value.length;
    } else if (this.options.forceString) {
      return JSON.stringify(value).length;
    } else if (_isArray(value)) {
      return this.options.arrayValueSize * value.length;
    } else if (_isNumber(value)) {
      return 8;
    } else if (_isObject(value)) {
      return this.options.objectValueSize * _size(value);
    } else {
      return 0;
    }
  }

• example usage

  ...
    } else {
      throw err;
    }
  }
  existent = false;
  if (this.data[key]) {
    existent = true;
    this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
  }
  this.data[key] = this._wrap(value, ttl);
  this.stats.vsize += this._getValLength(value);
  if (!existent) {
    this.stats.ksize += this._getKeyLength(key);
    this.stats.keys++;
  }
  ...

function node-cache.node_cache.prototype._initErrors ()

• description and source-code

  _initErrors = function () {
    var _errMsg, _errT, ref;
    this.ERRORS = {};
    ref = this._ERRORS;
    for (_errT in ref) {
      _errMsg = ref[_errT];
      this.ERRORS[_errT] = _template(_errMsg);
    }
  }

• example usage

  ...
  this.keys = bind(this.keys, this);
  this.getTtl = bind(this.getTtl, this);
  this.ttl = bind(this.ttl, this);
  this.del = bind(this.del, this);
  this.set = bind(this.set, this);
  this.mget = bind(this.mget, this);
  this.get = bind(this.get, this);
  this._initErrors();
  this.data = {};
  this.options = _assignIn({
    forceString: false,
    objectValueSize: 80,
    arrayValueSize: 40,
    stdTTL: 0,
    checkperiod: 600,
  ...

function node-cache.node_cache.prototype._isInvalidKey (key)

• description and source-code

  _isInvalidKey = function (key) {
    var ref;
    if (ref = typeof key, indexOf.call(this.validKeyTypes, ref) < 0) {
      return this._error("EKEYTYPE", {
        type: typeof key
      });
    }
  }

• example usage

  ...
  
      NodeCache.prototype.get = function(key, cb, errorOnMissing) {
  var _err, _ret, err;
  if (typeof cb === "boolean" && arguments.length === 2) {
    errorOnMissing = cb;
    cb = void 0;
  }
  if ((err = this._isInvalidKey(key)) != null) {
    if (cb != null) {
      cb(err);
      return;
    } else {
      throw err;
    }
  }
  ...

function node-cache.node_cache.prototype._killCheckPeriod ()

• description and source-code

  _killCheckPeriod = function () {
    if (this.checkTimeout != null) {
      return clearTimeout(this.checkTimeout);
    }
  }

• example usage

  ...
    this.stats = {
      hits: 0,
      misses: 0,
      keys: 0,
      ksize: 0,
      vsize: 0
    };
    this._killCheckPeriod();
    this._checkData(_startPeriod);
    this.emit("flush");
  };
  
  NodeCache.prototype.close = function() {
    this._killCheckPeriod();
  };
  ...

function node-cache.node_cache.prototype._unwrap (value, asClone)

• description and source-code

  _unwrap = function (value, asClone) {
    if (asClone == null) {
      asClone = true;
    }
    if (!this.options.useClones) {
      asClone = false;
    }
    if (value.v != null) {
      if (asClone) {
        return clone(value.v);
      } else {
        return value.v;
      }
    }
    return null;
  }

• example usage

  ...
      return;
    } else {
      throw err;
    }
  }
  if ((this.data[key] != null) && this._check(key, this.data[key])) {
    this.stats.hits++;
    _ret = this._unwrap(this.data[key]);
    if (cb != null) {
      cb(null, _ret);
    }
    return _ret;
  } else {
    this.stats.misses++;
    if (this.options.errorOnMissing || errorOnMissing) {
  ...

function node-cache.node_cache.prototype._wrap (value, ttl, asClone)

• description and source-code

  _wrap = function (value, ttl, asClone) {
    var livetime, now, oReturn, ttlMultiplicator;
    if (asClone == null) {
      asClone = true;
    }
    if (!this.options.useClones) {
      asClone = false;
    }
    now = Date.now();
    livetime = 0;
    ttlMultiplicator = 1000;
    if (ttl === 0) {
      livetime = 0;
    } else if (ttl) {
      livetime = now + (ttl * ttlMultiplicator);
    } else {
      if (this.options.stdTTL === 0) {
        livetime = this.options.stdTTL;
      } else {
        livetime = now + (this.options.stdTTL * ttlMultiplicator);
      }
    }
    return oReturn = {
      t: livetime,
      v: asClone ? clone(value) : value
    };
  }

• example usage

  ...
    }
  }
  existent = false;
  if (this.data[key]) {
    existent = true;
    this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
  }
  this.data[key] = this._wrap(value, ttl);
  this.stats.vsize += this._getValLength(value);
  if (!existent) {
    this.stats.ksize += this._getKeyLength(key);
    this.stats.keys++;
  }
  this.emit("set", key, value);
  if (cb != null) {
  ...

function node-cache.node_cache.prototype.close ()

• description and source-code

  close = function () {
    this._killCheckPeriod();
  }

• example usage

  ...
        vsize: 0    // global value size count
      }
    */
  ```
  
  ## Close the cache:
  
  `myCache.close()`
  
  This will clear the interval timeout which is set on check period option.
  
  ```js
  myCache.close();
  ```
  ...

function node-cache.node_cache.prototype.constructor (options)

• description and source-code

  function NodeCache(options) {
    this.options = options != null ? options : {};
    this._initErrors = bind(this._initErrors, this);
    this._error = bind(this._error, this);
    this._getValLength = bind(this._getValLength, this);
    this._wrap = bind(this._wrap, this);
    this._isInvalidKey = bind(this._isInvalidKey, this);
    this._check = bind(this._check, this);
    this._checkData = bind(this._checkData, this);
    this.close = bind(this.close, this);
    this.flushAll = bind(this.flushAll, this);
    this.getStats = bind(this.getStats, this);
    this.keys = bind(this.keys, this);
    this.getTtl = bind(this.getTtl, this);
    this.ttl = bind(this.ttl, this);
    this.del = bind(this.del, this);
    this.set = bind(this.set, this);
    this.mget = bind(this.mget, this);
    this.get = bind(this.get, this);
    this._initErrors();
    this.data = {};
    this.options = _assignIn({
      forceString: false,
      objectValueSize: 80,
      arrayValueSize: 40,
      stdTTL: 0,
      checkperiod: 600,
      useClones: true,
      errorOnMissing: false
    }, this.options);
    this.stats = {
      hits: 0,
      misses: 0,
      keys: 0,
      ksize: 0,
      vsize: 0
    };
    this.validKeyTypes = ["string", "number"];
    this._checkData();
    return;
  }

• example usage

  n/a

function node-cache.node_cache.prototype.del (keys, cb)

• description and source-code

  del = function (keys, cb) {
    var delCount, err, i, key, len, oldVal;
    if (!_isArray(keys)) {
      keys = [keys];
    }
    delCount = 0;
    for (i = 0, len = keys.length; i < len; i++) {
      key = keys[i];
      if ((err = this._isInvalidKey(key)) != null) {
        if (cb != null) {
          cb(err);
          return;
        } else {
          throw err;
        }
      }
      if (this.data[key] != null) {
        this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
        this.stats.ksize -= this._getKeyLength(key);
        this.stats.keys--;
        delCount++;
        oldVal = this.data[key];
        delete this.data[key];
        this.emit("del", key, oldVal.v);
      } else {
        this.stats.misses++;
      }
    }
    if (cb != null) {
      cb(null, delCount);
    }
    return delCount;
  }

• example usage

  ...
  
  **Since `2.0.0`**:
  
  The method for mget changed from `.get( [ "a", "b" ] )` to `.mget( [ "a", "b" ] )`
  
  ## Delete a key (DEL):
  
  `myCache.del( key, [callback] )`
  
  Delete a key. Returns the number of deleted entries. A delete will never fail.
  
  ```js
  myCache.del( "myKey", function( err, count ){
  if( !err ){
    console.log( count ); // 1
  ...

function node-cache.node_cache.prototype.flushAll (_startPeriod)

• description and source-code

  flushAll = function (_startPeriod) {
    if (_startPeriod == null) {
      _startPeriod = true;
    }
    this.data = {};
    this.stats = {
      hits: 0,
      misses: 0,
      keys: 0,
      ksize: 0,
      vsize: 0
    };
    this._killCheckPeriod();
    this._checkData(_startPeriod);
    this.emit("flush");
  }

• example usage

  ...
      vsize: 0    // global value size count
    }
  */
  ```
  
  ## Flush all data (FLUSH):
  
  `myCache.flushAll()`
  
  Flush all data.
  
  ```js
  myCache.flushAll();
  myCache.getStats();
  /*
  ...

function node-cache.node_cache.prototype.get (key, cb, errorOnMissing)

• description and source-code

  get = function (key, cb, errorOnMissing) {
    var _err, _ret, err;
    if (typeof cb === "boolean" && arguments.length === 2) {
      errorOnMissing = cb;
      cb = void 0;
    }
    if ((err = this._isInvalidKey(key)) != null) {
      if (cb != null) {
        cb(err);
        return;
      } else {
        throw err;
      }
    }
    if ((this.data[key] != null) && this._check(key, this.data[key])) {
      this.stats.hits++;
      _ret = this._unwrap(this.data[key]);
      if (cb != null) {
        cb(null, _ret);
      }
      return _ret;
    } else {
      this.stats.misses++;
      if (this.options.errorOnMissing || errorOnMissing) {
        _err = this._error("ENOTFOUND", {
          key: key
        }, cb);
        if (_err != null) {
          throw _err;
        }
        return;
      } else {
        if (cb != null) {
          cb(null, void 0);
        }
      }
      return void 0;
    }
  }

• example usage

  ...
  success = myCache.set( "myKey", obj, 10000 );
  // true
  ```
  
  
  ## Retrieve a key (GET):
  
  `myCache.get( key, [callback] )`
  
  Gets a saved value from the cache.
  Returns a `undefined` if not found or expired.
  If the value was found it returns an object with the `key` `value` pair.
  
  ```js
  myCache.get( "myKey", function( err, value ){
  ...

function node-cache.node_cache.prototype.getStats ()

• description and source-code

  getStats = function () {
    return this.stats;
  }

• example usage

  ...
  console.log( mykeys );
  // [ "all", "my", "keys", "foo", "bar" ]
  
  ```
  
  ## Statistics (STATS):
  
  `myCache.getStats()`
  
  Returns the statistics.
  
  ```js
  myCache.getStats();
  /*
    {
  ...

function node-cache.node_cache.prototype.getTtl (key, cb)

• description and source-code

  getTtl = function (key, cb) {
    var _ttl, err;
    if (!key) {
      if (cb != null) {
        cb(null, void 0);
      }
      return void 0;
    }
    if ((err = this._isInvalidKey(key)) != null) {
      if (cb != null) {
        cb(err);
        return;
      } else {
        throw err;
      }
    }
    if ((this.data[key] != null) && this._check(key, this.data[key])) {
      _ttl = this.data[key].t;
      if (cb != null) {
        cb(null, _ttl);
      }
      return _ttl;
    } else {
      if (cb != null) {
        cb(null, void 0);
      }
      return void 0;
    }
  }

• example usage

  ...
      // ... do something ...
    }
  });
  ```
  
  ## Get TTL (getTTL):
  
  `myCache.getTtl( key, [callback] )`
  
  Receive the ttl of a key.
  You will get:
  - `undefined` if the key does not exist
  - `0` if this key has no ttl
  - a timestamp in ms until the key expires
  ...

function node-cache.node_cache.prototype.keys (cb)

• description and source-code

  keys = function (cb) {
    var _keys;
    _keys = Object.keys(this.data);
    if (cb != null) {
      cb(null, _keys);
    }
    return _keys;
  }

• example usage

  ...
  ts = myCache.getTtl( "unknownKey" )
  // ts = undefined
  
  ```
  
  ## List keys (KEYS)
  
  `myCache.keys( [callback] )`
  
  Returns an array of all existing keys.
  
  ```js
  // async
  myCache.keys( function( err, mykeys ){
  if( !err ){
  ...

function node-cache.node_cache.prototype.mget (keys, cb)

• description and source-code

  mget = function (keys, cb) {
    var _err, err, i, key, len, oRet;
    if (!_isArray(keys)) {
      _err = this._error("EKEYSTYPE");
      if (cb != null) {
        cb(_err);
      }
      return _err;
    }
    oRet = {};
    for (i = 0, len = keys.length; i < len; i++) {
      key = keys[i];
      if ((err = this._isInvalidKey(key)) != null) {
        if (cb != null) {
          cb(err);
          return;
        } else {
          throw err;
        }
      }
      if ((this.data[key] != null) && this._check(key, this.data[key])) {
        this.stats.hits++;
        oRet[key] = this._unwrap(this.data[key]);
      } else {
        this.stats.misses++;
      }
    }
    if (cb != null) {
      cb(null, oRet);
    }
    return oRet;
  }

• example usage

  ...
  } catch( err ){
      // ENOTFOUND: Key `not-existing-key` not found
  }
  ```
  
  ## Get multiple keys (MGET):
  
  `myCache.mget( [ key1, key2, ... ,keyn ], [callback] )`
  
  Gets multiple saved values from the cache.
  Returns an empty object `{}` if not found or expired.
  If the value was found it returns an object with the `key` `value` pair.
  
  ```js
  myCache.mget( [ "myKeyA", "myKeyB" ], function( err, value ){
  ...

function node-cache.node_cache.prototype.set (key, value, ttl, cb)

• description and source-code

  set = function (key, value, ttl, cb) {
    var err, existent;
    if (this.options.forceString && !_isString(value)) {
      value = JSON.stringify(value);
    }
    if (arguments.length === 3 && _isFunction(ttl)) {
      cb = ttl;
      ttl = this.options.stdTTL;
    }
    if ((err = this._isInvalidKey(key)) != null) {
      if (cb != null) {
        cb(err);
        return;
      } else {
        throw err;
      }
    }
    existent = false;
    if (this.data[key]) {
      existent = true;
      this.stats.vsize -= this._getValLength(this._unwrap(this.data[key], false));
    }
    this.data[key] = this._wrap(value, ttl);
    this.stats.vsize += this._getValLength(value);
    if (!existent) {
      this.stats.ksize += this._getKeyLength(key);
      this.stats.keys++;
    }
    this.emit("set", key, value);
    if (cb != null) {
      cb(null, true);
    }
    return true;
  }

• example usage

  ...
  ```js
  const NodeCache = require( "node-cache" );
  const myCache = new NodeCache( { stdTTL: 100, checkperiod: 120 } );
  ```
  
  ## Store a key (SET):
  
  `myCache.set( key, val, [ ttl ], [callback] )`
  
  Sets a `key` `value` pair. It is possible to define a `ttl` (in seconds).
  Returns `true` on success.
  
  ```js
  obj = { my: "Special", variable: 42 };
  myCache.set( "myKey", obj, function( err, success ){
  ...

function node-cache.node_cache.prototype.ttl ()

• description and source-code

  ttl = function () {
    var arg, args, cb, err, i, key, len, ttl;
    key = arguments[0], args = 2 <= arguments.length ? slice.call(arguments, 1) : [];
    for (i = 0, len = args.length; i < len; i++) {
      arg = args[i];
      switch (typeof arg) {
        case "number":
          ttl = arg;
          break;
        case "function":
          cb = arg;
      }
    }
    ttl || (ttl = this.options.stdTTL);
    if (!key) {
      if (cb != null) {
        cb(null, false);
      }
      return false;
    }
    if ((err = this._isInvalidKey(key)) != null) {
      if (cb != null) {
        cb(err);
        return;
      } else {
        throw err;
      }
    }
    if ((this.data[key] != null) && this._check(key, this.data[key])) {
      if (ttl >= 0) {
        this.data[key] = this._wrap(this.data[key].v, ttl, false);
      } else {
        this.del(key);
      }
      if (cb != null) {
        cb(null, true);
      }
      return true;
    } else {
      if (cb != null) {
        cb(null, false);
      }
      return false;
    }
  }

• example usage

  ...
  
  value = myCache.del( [ "A", "B", "C", "D" ] );
  // 1 - because A, B and C not exists
  ```
  
  ## Change TTL (TTL):
  
  `myCache.ttl( key, ttl, [callback] )`
  
  Redefine the ttl of a key. Returns true if the key has been found and changed. Otherwise returns false.
  If the ttl-argument isn't passed the default-TTL will be used.
  
  The key will be deleted when passing in a `ttl < 0`.
  
  ```js
  ...