建议为这里讨论的许多特性以及更好的兼容性使用抽象库。有很多选择：

jStorage或simpleStorage← 我的喜好本地饲料alekseykulikov/仓库拉文查尔商店.js← 另一个不错的选择对象管理组织本地数据存储

Stringify并不能解决所有问题

这里的答案似乎并没有涵盖JavaScript中可能的所有类型，因此这里有一些关于如何正确处理它们的简短示例：

// Objects and Arrays:
    var obj = {key: "value"};
    localStorage.object = JSON.stringify(obj);  // Will ignore private members
    obj = JSON.parse(localStorage.object);

// Boolean:
    var bool = false;
    localStorage.bool = bool;
    bool = (localStorage.bool === "true");

// Numbers:
    var num = 42;
    localStorage.num = num;
    num = +localStorage.num;    // Short for "num = parseFloat(localStorage.num);"

// Dates:
    var date = Date.now();
    localStorage.date = date;
    date = new Date(parseInt(localStorage.date));

// Regular expressions:
    var regex = /^No\.[\d]*$/i;     // Usage example: "No.42".match(regex);
    localStorage.regex = regex;
    var components = localStorage.regex.match("^/(.*)/([a-z]*)$");
    regex = new RegExp(components[1], components[2]);

// Functions (not recommended):
    function func() {}

    localStorage.func = func;
    eval(localStorage.func);      // Recreates the function with the name "func"

我不建议存储函数，因为eval（）是邪恶的，会导致安全、优化和调试方面的问题。

通常，eval（）不应在JavaScript代码中使用。

私人成员

使用JSON.stringify（）存储对象的问题是，该函数不能串行化私有成员。

这个问题可以通过重写.toString（）方法来解决（在web存储中存储数据时隐式调用）：

// Object with private and public members:
    function MyClass(privateContent, publicContent) {
        var privateMember = privateContent || "defaultPrivateValue";
        this.publicMember = publicContent  || "defaultPublicValue";

        this.toString = function() {
            return '{"private": "' + privateMember + '", "public": "' + this.publicMember + '"}';
        };
    }
    MyClass.fromString = function(serialisedString) {
        var properties = JSON.parse(serialisedString || "{}");
        return new MyClass(properties.private, properties.public);
    };

// Storing:
    var obj = new MyClass("invisible", "visible");
    localStorage.object = obj;

// Loading:
    obj = MyClass.fromString(localStorage.object);

循环引用

stringify无法处理的另一个问题是循环引用：

var obj = {};
obj["circular"] = obj;
localStorage.object = JSON.stringify(obj);  // Fails

在本例中，JSON.stringify（）将抛出TypeError“将循环结构转换为JSON”。

如果应支持存储循环引用，则可以使用JSON.stringify（）的第二个参数：

var obj = {id: 1, sub: {}};
obj.sub["circular"] = obj;
localStorage.object = JSON.stringify(obj, function(key, value) {
    if(key == 'circular') {
        return "$ref" + value.id + "$";
    } else {
        return value;
    }
});

然而，找到存储循环引用的有效解决方案高度依赖于需要解决的任务，恢复这样的数据也并非易事。

关于堆栈溢出处理这个问题已经有一些问题：Stringify（转换为JSON）一个具有循环引用的JavaScript对象

我建议使用Jackson js。它是一个库，用于处理对象的序列化和反序列化，同时基于修饰符保留其结构。

该库处理所有缺陷，如循环引用、属性别名等。

只需使用@JsonProperty（）和@JsonClassType（）修饰符来描述类。

使用以下方法序列化对象：

const objectMapper = new ObjectMapper();
localstore.setItem(key, objectMapper.stringify<yourObjectType>(yourObject));

要获得更详细的解释，请在此处查看我的答案：

Typescript对象序列化？

这里有Jackson js教程：

Jackson js：强大的JavaScript装饰器，可将对象序列化/反序列化为JSON，反之亦然（第1部分）

对变体的一个小改进：

Storage.prototype.setObject = function(key, value) {
    this.setItem(key, JSON.stringify(value));
}

Storage.prototype.getObject = function(key) {
    var value = this.getItem(key);
    return value && JSON.parse(value);
}

由于短路求值，如果key不在Storage中，getObject（）将立即返回null。如果值为“”（空字符串；JSON.parse（）无法处理），它也不会引发SyntaxError异常。

https://github.com/adrianmay/rhaboo是一个localStorage糖层，允许您编写如下内容：

var store = Rhaboo.persistent('Some name');
store.write('count', store.count ? store.count+1 : 1);
store.write('somethingfancy', {
  one: ['man', 'went'],
  2: 'mow',
  went: [  2, { mow: ['a', 'meadow' ] }, {}  ]
});
store.somethingfancy.went[1].mow.write(1, 'lawn');

它不使用JSON.stringify/parse，因为这对于大型对象来说是不准确和缓慢的。相反，每个终端值都有自己的localStorage条目。

你可能会猜到我可能和rhaboo有关系。

localStorage.setItem('user', JSON.stringify(user));

然后从存储中检索并再次转换为对象：

var user = JSON.parse(localStorage.getItem('user'));

If we need to delete all entries of the store we can simply do:

localStorage.clear();