关于Nodejs 内置对象大小

var cachelist = {};
function set(key,value){
cachelist[key] = new Buffer(value);
if (cachelist[key]===undefined){
return false;
}
}
function get(key){
if(cachelist[key]!=undefined){
return cachelist[key]
}else{
return undefined
}
}
function del(key){
if(cachelist[key]){
delete cachelist[key];
return true;
}else{
return false;
}
}
function append(key,value){
if(cachelist[key]){
delete cachelist[key];
cachelist[key] = new Buffer(value);
}
else{
return false;
}
}
function cas(key,value){
if(cachelist[key]){
append(key,value);
}else{
set(key,value);
}
}
function get_multi(lis){
var tmp = [];
for(var i = 0,len = lis.length;i<len;i++){
if(get(lis[i])!=undefined){
tmp.push(get(lis[i]))
}
}
return tmp;
}
function delete_mulit(lis){
for(var i = 0,len=lis.length;i < len;i++){
if(!del(lis[i])){
return lis[i];
}else{
del(lis[i])
}
}
}
function clear(){
for(var i in cachelist){
delete cachelist[i]
}
}
exports.set = set
exports.del = del;
exports.append = append;
exports.get_multi = get_multi;
exports.cas = cas;
exports.get = get;
exports.delete_mulit = delete_mulit;
exports.get_multi = get_multi;
exports.clear = clear;

用nodejs试着做了一个简单的缓存…发现几个问题想问下…nodejs是否对内置对象有大小限制

限制是多少,是根据服务器的内存来判断的?

yuanlaile 1楼•2 个月前

当然可以！下面是关于Node.js内置对象大小的相关讨论和示例代码。

关于Node.js内置对象大小

在Node.js中，内置对象（如数组、对象等）的大小并没有明确的硬性限制。然而，这些对象的大小会受到系统内存的限制。如果你尝试创建一个非常大的对象，可能会导致内存溢出（RangeError: Invalid array length 或 FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory）。

示例代码

const util = require('util');

// 缓存对象
var cachelist = {};

// 设置缓存
function set(key, value) {
    cachelist[key] = new Buffer.from(value);
    if (cachelist[key] === undefined) {
        return false;
    }
    return true;
}

// 获取缓存
function get(key) {
    if (cachelist[key] !== undefined) {
        return cachelist[key].toString();
    } else {
        return undefined;
    }
}

// 删除缓存
function del(key) {
    if (cachelist[key]) {
        delete cachelist[key];
        return true;
    } else {
        return false;
    }
}

// 追加到缓存
function append(key, value) {
    if (cachelist[key]) {
        cachelist[key] = Buffer.concat([cachelist[key], new Buffer.from(value)]);
    } else {
        return false;
    }
}

// CAS操作
function cas(key, value) {
    if (cachelist[key]) {
        append(key, value);
    } else {
        set(key, value);
    }
}

// 批量获取缓存
function get_multi(keys) {
    let tmp = [];
    for (let key of keys) {
        let value = get(key);
        if (value !== undefined) {
            tmp.push(value);
        }
    }
    return tmp;
}

// 批量删除缓存
function delete_multi(keys) {
    for (let key of keys) {
        if (!del(key)) {
            return key;
        }
    }
    return null;
}

// 清空缓存
function clear() {
    for (let key in cachelist) {
        delete cachelist[key];
    }
}

module.exports = {
    set,
    del,
    append,
    get_multi,
    cas,
    get,
    delete_multi,
    clear
};

解释

Buffer 对象：使用 Buffer 来存储二进制数据。Buffer 是 Node.js 中用于处理二进制数据的内置对象。
设置缓存：set 函数将键值对存储在 cachelist 中，并使用 Buffer 存储值。
获取缓存：get 函数从 cachelist 中获取值，并将其转换为字符串返回。
追加缓存：append 函数将新值追加到现有缓存中。
CAS操作：cas 函数实现了比较并交换（Compare And Swap）逻辑。
批量操作：get_multi 和 delete_multi 分别实现了批量获取和删除缓存的功能。
清空缓存：clear 函数清空整个缓存对象。

注意事项

内存限制：由于 Node.js 的内存管理依赖于 V8 引擎，所以对象的大小最终受限于可用的系统内存。如果缓存的数据过大，可能会导致内存溢出错误。
性能：频繁地创建和销毁大对象可能会影响性能。建议使用更高效的数据结构或工具，如 Redis 等外部缓存服务。

希望这能帮助你更好地理解和使用 Node.js 中的内置对象大小。

sinazl 2楼•2 个月前作者

只听说过nodejs单个进程占用内存有限制，最大是1.5G

zlyuanteng 3楼•2 个月前

那我多创建几个进程,这种用内置对方的也是可行的咯…试下再说…www

wuwangju 4楼•2 个月前

关于 Node.js 内置对象的大小限制，Node.js 本身并没有明确的内置对象大小限制。但是，由于 JavaScript 运行时环境和底层操作系统资源的限制，你可以遇到一些实际的限制：

内存限制：每个 Node.js 进程都有一个最大可用内存限制。默认情况下，这个限制通常是 1.4GB 左右（具体值取决于操作系统和架构）。你可以通过修改 V8 的堆大小来增加内存限制，但这仍然受到系统可用内存的限制。
对象大小：JavaScript 对象的大小受限于可用内存。如果你试图存储非常大的数据（例如大文件），可能会超出内存限制导致进程崩溃或性能下降。
垃圾回收：频繁地创建和删除大量对象可能会导致垃圾回收压力增大，从而影响程序性能。

下面是一个改进版的代码，去除了不必要的 delete 操作，并且优化了一些逻辑：

const { Buffer } = require('buffer');

class Cache {
    constructor() {
        this.cache = {};
    }

    set(key, value) {
        this.cache[key] = Buffer.from(value);
        return this.cache[key] !== undefined;
    }

    get(key) {
        return this.cache[key];
    }

    del(key) {
        const deleted = this.cache[key] !== undefined;
        delete this.cache[key];
        return deleted;
    }

    append(key, value) {
        const buffer = this.get(key);
        if (buffer) {
            buffer.write(value, buffer.length);
            return true;
        }
        return this.set(key, value);
    }

    cas(key, value) {
        if (this.cache[key]) {
            this.append(key, value);
        } else {
            this.set(key, value);
        }
    }

    getMulti(keys) {
        return keys.map(key => this.get(key)).filter(buffer => buffer !== undefined);
    }

    deleteMulti(keys) {
        return keys.filter(key => !this.del(key));
    }

    clear() {
        this.cache = {};
    }
}

module.exports = Cache;

关键点解释：

使用类结构：将方法封装在类中，提高代码的可读性和复用性。
使用 Buffer.from：直接从字符串创建 Buffer，避免重复创建相同的对象。
简化逻辑：移除不必要的 delete 操作，减少内存占用。

这样可以更好地管理内存和性能。