Nodejs可以这样来当缓存用么，求提意见

为了减轻数据库压力，但不用redis 或 memcache 不知道可行否 Data = new Object(); build();

function build(){

Data = new Object();
Data.repertory = new Array();
Data.del = function (key, value){
if (typeof Data.repertory[key] == “undefined”) {
return true;
}
delete Data.repertory[key];
return true;
}
Data.set = function (key, value){
Data.repertory[key] = value;
return true;
}
Data.get = function (key){
if (typeof Data.repertory[key] == “undefined”) {
return false;
}
return Data.repertory[key];
}
Data.check = function (key, value){
if (typeof Data.repertory[key] == “undefined”){
return false;
}
if (Data.repertory[key] == value){
    return true;
} else {
    return false;
}
}
Data.inc = function (key, value){
if (typeof Data.repertory[key] == “undefined”){
return true;
}
Data.repertory[key] += value;
return true;
}
Data.dec = function (key, value){
if (typeof Data.repertory[key] == “undefined”){
return true;
}
Data.repertory[key] -= value;
return true;
}
Data.push = function (key, value){
if (typeof Data.repertory[key] == “undefined”){
Data.repertory[key] = new Array();
}
Data.repertory[key].push(value);
return true;
}
Data.fun = function(fun){
fun(Data.repertory);
}
Data.remove = function (key, value, flag){
if (typeof Data.repertory[key] == “undefined”){
return true;
}
var i;
if (flag){
    for (i = 0; i&lt;Data.repertory[key].length; i++){
        if (Data.repertory[key][i][flag] == value){
            Data.repertory[key].splice(i, 1);
            break;
        }
    }
}  else {
    for (i = 0; i&lt;Data.repertory[key].length; i++){
        if (Data.repertory[key][i] == value){
            Data.repertory[key].splice(i, 1);
            break;
        }
    }
}
return true;
}

}

vueper 1楼

当然可以！使用纯JavaScript对象作为内存缓存是一种简单有效的方法。不过，这种方式有一些限制，比如重启应用时数据会丢失，并且不适合分布式环境。但如果你的应用不需要这些特性，这种方法还是非常有效的。

以下是改进后的代码，包含了一些常见的缓存操作方法，并且添加了简单的错误处理和类型检查：

const Data = {};

function build() {
    Data.repertory = {};
    
    // 清除指定键的值
    Data.del = function (key) {
        if (!Data.repertory.hasOwnProperty(key)) {
            return false;
        }
        delete Data.repertory[key];
        return true;
    }

    // 设置键值对
    Data.set = function (key, value) {
        Data.repertory[key] = value;
        return true;
    }

    // 获取指定键的值
    Data.get = function (key) {
        return Data.repertory[key] || false;
    }

    // 检查键的值是否相等
    Data.check = function (key, value) {
        const storedValue = Data.get(key);
        return storedValue === value;
    }

    // 增加数值
    Data.inc = function (key, value = 1) {
        if (!Data.repertory.hasOwnProperty(key)) {
            Data.repertory[key] = 0;
        }
        Data.repertory[key] += value;
        return true;
    }

    // 减少数值
    Data.dec = function (key, value = 1) {
        if (!Data.repertory.hasOwnProperty(key)) {
            Data.repertory[key] = 0;
        }
        Data.repertory[key] -= value;
        return true;
    }

    // 向数组中添加元素
    Data.push = function (key, value) {
        if (!Array.isArray(Data.repertory[key])) {
            Data.repertory[key] = [];
        }
        Data.repertory[key].push(value);
        return true;
    }

    // 删除数组中的特定元素
    Data.remove = function (key, value) {
        if (!Array.isArray(Data.repertory[key])) {
            return false;
        }
        const index = Data.repertory[key].indexOf(value);
        if (index !== -1) {
            Data.repertory[key].splice(index, 1);
            return true;
        }
        return false;
    }
}

// 初始化缓存
build();

// 示例用法
console.log(Data.set('user', { name: 'Alice' })); // 设置键值对
console.log(Data.get('user')); // 获取键值对
console.log(Data.del('user')); // 删除键值对

解释

初始化：Data.repertory 是一个对象，用于存储缓存数据。
删除：Data.del 方法用于删除指定键的值。
设置：Data.set 方法用于设置键值对。
获取：Data.get 方法用于获取指定键的值。
检查：Data.check 方法用于检查指定键的值是否等于给定的值。
增加/减少：Data.inc 和 Data.dec 方法用于增加或减少指定键的数值。
数组操作：Data.push 和 Data.remove 方法用于向数组中添加或删除元素。

这种简单的内存缓存方式适用于小规模应用或开发阶段，但在生产环境中，建议使用更健壮的解决方案如 Redis 或 Memcached。

wuwangju 2楼

缓存就是把临时数据存在内存，node当然可以做，如果只是静态数据（即不会更改的配置信息）可以这么干，但是你要把node当缓存服务器来用，不建议这么做，像memcache、redis这样可以做缓存的，在功能上具有很大的弹性，性能又做了很多优化，何必重复造轮子了。

wuwangju 3楼

看不懂，似乎很高级的样子。

bupafengyu 4楼

感觉如果不控制内存限制，很容易造成内存泄漏，还是不用了～

h691938207 5楼

缓存请使用单核心。

eggper 6楼

额，多个进程就有问题了

nodeper 7楼作者

N个用户一进来，你的内存就满了。

vueper 8楼

https://www.npmjs.org/package/lru-cache

ionicwang 9楼

大致看了一下，推荐一下我用过的两个包：

lru-cache
node-cache

其实虽然和那些真正存储媒介相比有差异，但是这种缓存思维是肯定有一定好处的

eggper 10楼

如果是考虑tcp请求延迟，还不如在nodejs同一个服务器上装个redis当缓存。 js的计算效率始终是赶不上c c++编写的数据库的。

h691938207 11楼

这是在内存中，一个执行流有效，当第二个请求的人来了；它就无效了吧；

sinazl 12楼

你提供的方式确实可以用作简单的内存缓存，但有一些地方可以优化，并且需要注意一些潜在问题。以下是一些改进建议和示例代码：

改进点：

使用Map代替Object：Map提供了更好的键值对存储方式，尤其是当键为对象时。
异步操作支持：如果需要处理并发请求，可以考虑使用async/await或Promise来避免数据竞争。
错误处理：增加错误处理逻辑，使代码更健壮。
类型检查：增加参数类型的检查，确保输入正确。

示例代码：

const Data = new Map();

function build() {
    // 初始化Map，也可以在这里添加预设的数据
}

// 设置值
Data.set = (key, value) => {
    Data.set(key, value);
    return true;
};

// 获取值
Data.get = (key) => {
    return Data.get(key);
};

// 删除值
Data.delete = (key) => {
    return Data.delete(key);
};

// 检查值
Data.has = (key, value) => {
    const val = Data.get(key);
    return val !== undefined && val === value;
};

// 自增
Data.inc = (key, value) => {
    const currentVal = Data.get(key);
    if (currentVal !== undefined) {
        Data.set(key, currentVal + value);
        return true;
    }
    return false;
};

// 自减
Data.dec = (key, value) => {
    const currentVal = Data.get(key);
    if (currentVal !== undefined) {
        Data.set(key, currentVal - value);
        return true;
    }
    return false;
};

// 添加到数组
Data.push = (key, value) => {
    let values = Data.get(key);
    if (!values) {
        values = [];
        Data.set(key, values);
    }
    values.push(value);
    return true;
};

// 移除特定值
Data.remove = (key, value) => {
    const values = Data.get(key);
    if (values) {
        const index = values.indexOf(value);
        if (index !== -1) {
            values.splice(index, 1);
            return true;
        }
    }
    return false;
};

build();

注意事项：

内存限制：这种方式依赖于应用的内存，不适合大规模或长时间运行的应用。
数据持久化：这种方式不支持数据持久化，如果服务重启，所有缓存将丢失。
并发访问：如果有多线程或多进程同时访问，可能会出现数据竞争问题，需通过锁机制或其他同步手段解决。

以上就是对你提出的方法的一些改进建议和示例代码。