/
index.js
155 lines (144 loc) · 3.82 KB
/
index.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
/**
* memoried 0.1.0
* https://github.com/open-node/memoried
* (c) 2014-2014 Redston Zhao code, document
* memoried may be freely distributed under the MIT license.
*/
(function() {
var toString = Object.prototype.toString
, __slice = [].slice
, data
, flash
, wrapper
, wrapperSync
, memoried
, isFunction = function(value) {
return toString.call(value) == '[object Function]';
};
data = {};
setInterval(function() {
var cache, key, now;
now = Date.now();
for (key in data) {
cache = data[key];
if (now < cache.expired) {
delete data[key];
}
}
return true;
}, 300 * 1000);
flash = {
get: function(key) {
var cache;
cache = data[key];
if (!cache) {
return null;
}
if (cache.expired > Date.now()) {
return cache.value;
}
delete data[key];
return null;
},
set: function(key, value, life) {
var expired;
if (life == null) {
life = 600;
}
expired = Date.now() + life * 1000;
data[key] = {
expired: expired,
value: value
};
return true;
}
};
wrapperSync = function(key, func, life, bind) {
var regxp = /\{(\d+)\}/g
, keyReplace = regxp.test(key);
return function() {
var cacheKey
, args = arguments.length ? __slice.call(arguments, 0) : []
, ret;
if (keyReplace) {
cacheKey = key.replace(/\{(\d+)\}/g, function(m, i) {
return args[i];
});
} else {
cacheKey = key;
}
ret = flash.get(cacheKey);
if (ret) {
return ret;
}
ret = func.apply(bind, args);
flash.set(cacheKey, ret, life);
return ret;
};
};
wrapper = function(key, func, life, bind) {
var regxp = /\{(\d+)\}/g
, keyReplace = regxp.test(key);
return function() {
var cacheKey
, args = arguments.length ? __slice.call(arguments, 0) : []
, ret
, callback = args.pop();
if (keyReplace) {
cacheKey = key.replace(/\{(\d+)\}/g, function(m, i) {
return args[i];
});
} else {
cacheKey = key;
}
ret = flash.get(cacheKey);
if (ret) {
return callback(null, ret);
}
args.push(function(error, result) {
if (error) {
return callback(error, result)
}
flash.set(cacheKey, result, life);
callback(error, result);
});
func.apply(bind, args);
};
};
memoried = function(key, value, life, opts) {
var len = arguments.length
, bind
, opts = opts || {};
if (len === 0) {
throw Error('argument Error, must has argument 1 more');
} else if (arguments.length === 1) {
return flash.get(key);
} else if (isFunction(value)) {
bind = opts && (opts.bind || this);
if (opts.sync) {
return wrapperSync(key, value, life, bind);
} else {
return wrapper(key, value, life, bind);
}
} else {
return flash.set(key, value, life);
}
};
if (module && module.exports) {
module.exports = memoried;
} else if (window) {
window.memoried = memoried;
}
// AMD registration happens at the end for compatibility with AMD loaders
// that may not enforce next-turn semantics on modules. Even though general
// practice for AMD registration is to be anonymous, underscore registers
// as a named module because, like jQuery, it is a base library that is
// popular enough to be bundled in a third party lib, but not be part of
// an AMD load request. Those cases could generate an error when an
// anonymous define() is called outside of a loader request.
if (typeof define === 'function' && define.amd) {
define('memoried', [], function() {
return memoried;
});
}
}).call(this);