如何在HTML5 localStorage/会话存储中存储对象

我想在HTML5localStorage中存储一个JavaScript对象,但我的对象显然被转换为字符串。

我可以使用localStorage存储和检索原始JavaScript类型和数组,但对象似乎不起作用。他们应该吗?

这是我的代码:

var testObject = { 'one': 1, 'two': 2, 'three': 3 };console.log('typeof testObject: ' + typeof testObject);console.log('testObject properties:');for (var prop in testObject) {console.log('  ' + prop + ': ' + testObject[prop]);}
// Put the object into storagelocalStorage.setItem('testObject', testObject);
// Retrieve the object from storagevar retrievedObject = localStorage.getItem('testObject');
console.log('typeof retrievedObject: ' + typeof retrievedObject);console.log('Value of retrievedObject: ' + retrievedObject);

控制台输出是

typeof testObject: objecttestObject properties:one: 1two: 2three: 3typeof retrievedObject: stringValue of retrievedObject: [object Object]

在我看来,setItem方法在存储之前将输入转换为字符串。

我在Safari,Chrome和Firefox中看到了这种行为,所以我认为这是我对HTML5网络存储规范的误解,而不是浏览器特定的bug或限制。

我试图理解2中描述的结构克隆算法。我不完全理解它在说什么,但也许我的问题与我的对象的属性不可枚举有关(???)。

有没有简单的解决方法?


更新:W3C最终改变了他们对结构化克隆规范的看法,并决定更改规范以匹配实现。参见12111-存储对象getItem(key)方法的规范与实现行为不匹配。所以这个问题不再100%有效,但答案可能仍然令人感兴趣。

1388248 次浏览

查看苹果Mozilla又是Mozilla留档,功能似乎仅限于处理字符串键/值对。

解决方法可以是在存储对象之前将其字符串化,然后在检索时解析它:

var testObject = { 'one': 1, 'two': 2, 'three': 3 };
// Put the object into storagelocalStorage.setItem('testObject', JSON.stringify(testObject));
// Retrieve the object from storagevar retrievedObject = localStorage.getItem('testObject');
console.log('retrievedObject: ', JSON.parse(retrievedObject));

您可能会发现使用以下方便的方法扩展Storage对象很有用:

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

通过这种方式,您可以获得您真正想要的功能,即使在API下面只支持字符串。

变体的一个小改进:

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不在存储中,getObject()立即返回null。如果value"",它也不会抛出SyntaxError异常(空字符串;JSON.parse()无法处理)。

为Storage对象创建一个facade是一个很棒的解决方案。这样,您就可以实现自己的getset方法。对于我的API,我为localStorage创建了一个facade,然后在设置和获取时检查它是否是一个对象。

var data = {set: function(key, value) {if (!key || !value) {return;}
if (typeof value === "object") {value = JSON.stringify(value);}localStorage.setItem(key, value);},get: function(key) {var value = localStorage.getItem(key);
if (!value) {return;}
// assume it is an object that has been stringifiedif (value[0] === "{") {value = JSON.parse(value);}
return value;}}

理论上,可以存储具有函数的对象:

function store (a){var c = {f: {}, d: {}};for (var k in a){if (a.hasOwnProperty(k) && typeof a[k] === 'function'){c.f[k] = encodeURIComponent(a[k]);}}
c.d = a;var data = JSON.stringify(c);window.localStorage.setItem('CODE', data);}
function restore (){var data = window.localStorage.getItem('CODE');data = JSON.parse(data);var b = data.d;
for (var k in data.f){if (data.f.hasOwnProperty(k)){b[k] = eval("(" + decodeURIComponent(data.f[k]) + ")");}}
return b;}

但是,函数序列化/反序列化是不可靠的,因为它依赖于实现

有一个很棒的库可以包装许多解决方案,因此它甚至支持名为jStorage的旧浏览器

你可以设置一个对象

$.jStorage.set(key, value)

并轻松取回它

value = $.jStorage.get(key)value = $.jStorage.get(key, "default value")

我来到这篇文章之前,偶然发现了另一个被关闭的文章,这个帖子的标题是“如何在localStorage中存储数组?”。这很好,除了两个线程都没有提供关于如何在localStorage中维护数组的完整答案之外-但是我已经设法根据两个线程中包含的信息制定了一个解决方案。

因此,如果其他人希望能够在数组中推送/弹出/移位项目,并且他们希望该数组存储在localStorage或实际上是sionsionStorage中,那么您可以这样做:

Storage.prototype.getArray = function(arrayName) {var thisArray = [];var fetchArrayObject = this.getItem(arrayName);if (typeof fetchArrayObject !== 'undefined') {if (fetchArrayObject !== null) { thisArray = JSON.parse(fetchArrayObject); }}return thisArray;}
Storage.prototype.pushArrayItem = function(arrayName,arrayItem) {var existingArray = this.getArray(arrayName);existingArray.push(arrayItem);this.setItem(arrayName,JSON.stringify(existingArray));}
Storage.prototype.popArrayItem = function(arrayName) {var arrayItem = {};var existingArray = this.getArray(arrayName);if (existingArray.length > 0) {arrayItem = existingArray.pop();this.setItem(arrayName,JSON.stringify(existingArray));}return arrayItem;}
Storage.prototype.shiftArrayItem = function(arrayName) {var arrayItem = {};var existingArray = this.getArray(arrayName);if (existingArray.length > 0) {arrayItem = existingArray.shift();this.setItem(arrayName,JSON.stringify(existingArray));}return arrayItem;}
Storage.prototype.unshiftArrayItem = function(arrayName,arrayItem) {var existingArray = this.getArray(arrayName);existingArray.unshift(arrayItem);this.setItem(arrayName,JSON.stringify(existingArray));}
Storage.prototype.deleteArray = function(arrayName) {this.removeItem(arrayName);}

示例用法-在localStorage数组中存储简单字符串:

localStorage.pushArrayItem('myArray','item one');localStorage.pushArrayItem('myArray','item two');

示例用法-在会话存储数组中存储对象:

var item1 = {}; item1.name = 'fred'; item1.age = 48;sessionStorage.pushArrayItem('myArray',item1);
var item2 = {}; item2.name = 'dave'; item2.age = 22;sessionStorage.pushArrayItem('myArray',item2);

操作数组的常用方法:

.pushArrayItem(arrayName,arrayItem); -> adds an element onto end of named array.unshiftArrayItem(arrayName,arrayItem); -> adds an element onto front of named array.popArrayItem(arrayName); -> removes & returns last array element.shiftArrayItem(arrayName); -> removes & returns first array element.getArray(arrayName); -> returns entire array.deleteArray(arrayName); -> removes entire array from storage

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条目。

你大概能猜到我可能和罗伯有关系。

Stringify并不能解决所有问题

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

// Objects and Arrays:var obj = {key: "value"};localStorage.object = JSON.stringify(obj);  // Will ignore private membersobj = 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;}});

但是,找到存储循环引用的有效解决方案在很大程度上取决于需要解决的任务,并且恢复此类数据也不是微不足道的。

已经有一些关于Stack Overflow处理这个问题的问题:Stringify(转换为JSON)带有循环引用的JavaScript对象

以下是代码由danott发布的一些扩展版本:

它还将从localStorage实现删除值,并展示如何添加Getter和Setter层,以便代替,

localstorage.setItem(preview, true)

你可以写

config.preview = true

好了,我们开始了:

var PT=Storage.prototype
if (typeof PT._setItem >='u')PT._setItem = PT.setItem;PT.setItem = function(key, value){if (typeof value >='u') //..undefinedthis.removeItem(key)elsethis._setItem(key, JSON.stringify(value));}
if (typeof PT._getItem >='u')PT._getItem = PT.getItem;PT.getItem = function(key){var ItemData = this._getItem(key)try{return JSON.parse(ItemData);}catch(e){return ItemData;}}
// Aliases for localStorage.set/getItemget = localStorage.getItem.bind(localStorage)set = localStorage.setItem.bind(localStorage)
// Create ConfigWrapperObjectvar config = {}
// Helper to create getter & setterfunction configCreate(PropToAdd){Object.defineProperty( config, PropToAdd, {get: function ()    { return (get(PropToAdd)    )},set: function (val) {         set(PropToAdd, val)}})}//------------------------------
// Usage Part// Create propertiesconfigCreate('preview')configCreate('notification')//...
// Configuration Data transfer// Setconfig.preview = true
// Getconfig.preview
// Deleteconfig.preview = undefined

好吧,你可以用.bind(...)去掉别名部分。然而,我只是把它放进去,因为知道这件事真的很好。我花了几个小时来找出为什么简单的get = localStorage.getItem;不起作用。

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

我做了一个不会破坏现有存储对象的东西,而是创建一个包装器,这样你就可以做你想做的事情。结果是一个普通对象,没有方法,可以像任何对象一样访问。

我做的东西。

如果你想让1localStorage属性有魔力:

var prop = ObjectStorage(localStorage, 'prop');

如果你需要几个:

var storage = ObjectStorage(localStorage, ['prop', 'more', 'props']);

你对prop或对象里面storage所做的一切都将自动保存到localStorage中。你总是在玩一个真实的对象,所以你可以这样做:

storage.data.list.push('more data');storage.another.list.splice(1, 2, {another: 'object'});

每个新对象里面一个被跟踪的对象将被自动跟踪。

最大的缺点:它依赖于Object.observe(),所以它的浏览器支持非常有限。而且看起来它不会很快出现在Firefox或Edge上。

另一种选择是使用现有的插件。

例如perissto是一个开源项目,它提供了一个简单的本地存储/会话存储接口,并自动持久化表单字段(输入、单选按钮和复选框)。

整体特征

(注:我是作者)

您可以使用ejson将对象存储为字符串。

EJSON是JSON的扩展,以支持更多类型。它支持所有JSON安全类型,以及:

所有EJSON序列化也是有效的JSON。例如,具有日期和二进制缓冲区的对象将在EJSON中序列化为:

{"d": {"$date": 1358205756553},"b": {"$binary": "c3VyZS4="}}

这是我使用ejson的localStorage包装器

https://github.com/UziTech/storage.js

我在我的包装器中添加了一些类型,包括正则表达式和函数

我做了另一个简约的包装器,只有20行代码,允许像它应该的那样使用它:

localStorage.set('myKey',{a:[1,2,5], b: 'ok'});localStorage.has('myKey');   // --> truelocalStorage.get('myKey');   // --> {a:[1,2,5], b: 'ok'}localStorage.keys();         // --> ['myKey']localStorage.remove('myKey');

您可以使用本地数据存储透明地存储JavaScript数据类型(数组、布尔值、日期、浮点数、整数、字符串和对象)。它还提供轻量级数据混淆、自动压缩字符串、促进按键(名称)和按(键)值查询,并通过前缀键来帮助在同一域内强制分段共享存储。

[免责声明]我是实用程序的作者[/免责声明]

示例:

localDataStorage.set( 'key1', 'Belgian' )localDataStorage.set( 'key2', 1200.0047 )localDataStorage.set( 'key3', true )localDataStorage.set( 'key4', { 'RSK' : [1,'3',5,'7',9] } )localDataStorage.set( 'key5', null )
localDataStorage.get( 'key1' )  // -->   'Belgian'localDataStorage.get( 'key2' )  // -->   1200.0047localDataStorage.get( 'key3' )  // -->   truelocalDataStorage.get( 'key4' )  // -->   Object {RSK: Array(5)}localDataStorage.get( 'key5' )  // -->   null

如您所见,原始值得到了尊重。

对于愿意设置和获取类型化属性的TypeScript用户:

/*** Silly wrapper to be able to type the storage keys*/export class TypedStorage<T> {
public removeItem(key: keyof T): void {localStorage.removeItem(key);}
public getItem<K extends keyof T>(key: K): T[K] | null {const data: string | null =  localStorage.getItem(key);return JSON.parse(data);}
public setItem<K extends keyof T>(key: K, value: T[K]): void {const data: string = JSON.stringify(value);localStorage.setItem(key, data);}}

示例用法

// write an interface for the storageinterface MyStore {age: number,name: string,address: {city:string}}
const storage: TypedStorage<MyStore> = new TypedStorage<MyStore>();
storage.setItem("wrong key", ""); // error unknown keystorage.setItem("age", "hello"); // error, age should be numberstorage.setItem("address", {city:"Here"}); // ok
const address: {city:string} = storage.getItem("address");

我找到了一种使它与具有循环引用的对象一起工作的方法。

让我们创建一个带有循环引用的对象。

obj = {L: {L: { v: 'lorem' },R: { v: 'ipsum' }},R: {L: { v: 'dolor' },R: {L: { v: 'sit' },R: { v: 'amet' }}}}obj.R.L.uncle = obj.L;obj.R.R.uncle = obj.L;obj.R.R.L.uncle = obj.R.L;obj.R.R.R.uncle = obj.R.L;obj.L.L.uncle = obj.R;obj.L.R.uncle = obj.R;

我们不能在这里做JSON.stringify,因为循环引用。

循环

LOCALSTORAGE.CYCLICJSON具有.stringify.parse,就像普通的JSON一样,但适用于具有循环引用的对象。(“作品”意味着解析(stringify(obj))和obj是深度相等的,并且具有相同的“内部等式”集)

但是我们可以使用快捷方式:

LOCALSTORAGE.setObject('latinUncles', obj)recovered = LOCALSTORAGE.getObject('latinUncles')

然后,recovered将与obj“相同”,如下所示:

[obj.L.L.v === recovered.L.L.v,obj.L.R.v === recovered.L.R.v,obj.R.L.v === recovered.R.L.v,obj.R.R.L.v === recovered.R.R.L.v,obj.R.R.R.v === recovered.R.R.R.v,obj.R.L.uncle === obj.L,obj.R.R.uncle === obj.L,obj.R.R.L.uncle === obj.R.L,obj.R.R.R.uncle === obj.R.L,obj.L.L.uncle === obj.R,obj.L.R.uncle === obj.R,recovered.R.L.uncle === recovered.L,recovered.R.R.uncle === recovered.L,recovered.R.R.L.uncle === recovered.R.L,recovered.R.R.R.uncle === recovered.R.L,recovered.L.L.uncle === recovered.R,recovered.L.R.uncle === recovered.R]

这是LOCALSTORAGE的实现

LOCALSTORAGE = (function(){"use strict";var ignore = [Boolean, Date, Number, RegExp, String];function primitive(item){if (typeof item === 'object'){if (item === null) { return true; }for (var i=0; i<ignore.length; i++){if (item instanceof ignore[i]) { return true; }}return false;} else {return true;}}function infant(value){return Array.isArray(value) ? [] : {};}function decycleIntoForest(object, replacer) {if (typeof replacer !== 'function'){replacer = function(x){ return x; }}object = replacer(object);if (primitive(object)) return object;var objects = [object];var forest  = [infant(object)];var bucket  = new WeakMap(); // bucket = inverse of objectsbucket.set(object, 0);function addToBucket(obj){var result = objects.length;objects.push(obj);bucket.set(obj, result);return result;}function isInBucket(obj){ return bucket.has(obj); }function processNode(source, target){Object.keys(source).forEach(function(key){var value = replacer(source[key]);if (primitive(value)){target[key] = {value: value};} else {var ptr;if (isInBucket(value)){ptr = bucket.get(value);} else {ptr = addToBucket(value);var newTree = infant(value);forest.push(newTree);processNode(value, newTree);}target[key] = {pointer: ptr};}});}processNode(object, forest[0]);return forest;};function deForestIntoCycle(forest) {var objects = [];var objectRequested = [];var todo = [];function processTree(idx) {if (idx in objects) return objects[idx];if (objectRequested[idx]) return null;objectRequested[idx] = true;var tree = forest[idx];var node = Array.isArray(tree) ? [] : {};for (var key in tree) {var o = tree[key];if ('pointer' in o) {var ptr = o.pointer;var value = processTree(ptr);if (value === null) {todo.push({node: node,key: key,idx: ptr});} else {node[key] = value;}} else {if ('value' in o) {node[key] = o.value;} else {throw new Error('unexpected')}}}objects[idx] = node;return node;}var result = processTree(0);for (var i = 0; i < todo.length; i++) {var item = todo[i];item.node[item.key] = objects[item.idx];}return result;};var console = {log: function(x){var the = document.getElementById('the');the.textContent = the.textContent + '\n' + x;},delimiter: function(){var the = document.getElementById('the');the.textContent = the.textContent +'\n*******************************************';}}function logCyclicObjectToConsole(root) {var cycleFree = decycleIntoForest(root);var shown = cycleFree.map(function(tree, idx) {return false;});var indentIncrement = 4;function showItem(nodeSlot, indent, label) {var leadingSpaces = ' '.repeat(indent);var leadingSpacesPlus = ' '.repeat(indent + indentIncrement);if (shown[nodeSlot]) {console.log(leadingSpaces + label + ' ... see above (object #' + nodeSlot + ')');} else {console.log(leadingSpaces + label + ' object#' + nodeSlot);var tree = cycleFree[nodeSlot];shown[nodeSlot] = true;Object.keys(tree).forEach(function(key) {var entry = tree[key];if ('value' in entry) {console.log(leadingSpacesPlus + key + ": " + entry.value);} else {if ('pointer' in entry) {showItem(entry.pointer, indent + indentIncrement, key);}}});}}console.delimiter();showItem(0, 0, 'root');};function stringify(obj){return JSON.stringify(decycleIntoForest(obj));}function parse(str){return deForestIntoCycle(JSON.parse(str));}var CYCLICJSON = {decycleIntoForest: decycleIntoForest,deForestIntoCycle : deForestIntoCycle,logCyclicObjectToConsole: logCyclicObjectToConsole,stringify : stringify,parse : parse}function setObject(name, object){var str = stringify(object);localStorage.setItem(name, str);}function getObject(name){var str = localStorage.getItem(name);if (str===null) return null;return parse(str);}return {CYCLICJSON : CYCLICJSON,setObject  : setObject,getObject  : getObject}})();obj = {L: {L: { v: 'lorem' },R: { v: 'ipsum' }},R: {L: { v: 'dolor' },R: {L: { v: 'sit' },R: { v: 'amet' }}}}obj.R.L.uncle = obj.L;obj.R.R.uncle = obj.L;obj.R.R.L.uncle = obj.R.L;obj.R.R.R.uncle = obj.R.L;obj.L.L.uncle = obj.R;obj.L.R.uncle = obj.R;
// LOCALSTORAGE.setObject('latinUncles', obj)// recovered = LOCALSTORAGE.getObject('latinUncles')// localStorage not available inside fiddle ):LOCALSTORAGE.CYCLICJSON.logCyclicObjectToConsole(obj)putIntoLS = LOCALSTORAGE.CYCLICJSON.stringify(obj);recovered = LOCALSTORAGE.CYCLICJSON.parse(putIntoLS);LOCALSTORAGE.CYCLICJSON.logCyclicObjectToConsole(recovered);
var the = document.getElementById('the');the.textContent = the.textContent + '\n\n' +JSON.stringify([obj.L.L.v === recovered.L.L.v,obj.L.R.v === recovered.L.R.v,obj.R.L.v === recovered.R.L.v,obj.R.R.L.v === recovered.R.R.L.v,obj.R.R.R.v === recovered.R.R.R.v,obj.R.L.uncle === obj.L,obj.R.R.uncle === obj.L,obj.R.R.L.uncle === obj.R.L,obj.R.R.R.uncle === obj.R.L,obj.L.L.uncle === obj.R,obj.L.R.uncle === obj.R,recovered.R.L.uncle === recovered.L,recovered.R.R.uncle === recovered.L,recovered.R.R.L.uncle === recovered.R.L,recovered.R.R.R.uncle === recovered.R.L,recovered.L.L.uncle === recovered.R,recovered.L.R.uncle === recovered.R])
<pre id='the'></pre>

如果没有字符串格式,则无法存储键值。

本地存储仅支持键/值的字符串格式。

这就是为什么您应该将数据转换为字符串,无论它是数组还是对象。

对于localStorage中的商店数据,首先使用JSON.stringify()方法对其进行字符串化。

var myObj = [{name:"test", time:"Date 2017-02-03T08:38:04.449Z"}];localStorage.setItem('item', JSON.stringify(myObj));

然后,当您想要检索数据时,您需要再次解析字符串以进行对象。

var getObj = JSON.parse(localStorage.getItem('item'));
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();

通函

在这个答案中,我专注于带有循环引用的纯数据对象(没有函数等),并开发了由Maja和数学云提到的想法(我使用他的测试用例和我的代码短了几倍)。

实际上,我们可以将JSON.stringify与正确的替代品一起使用——如果源对象包含对某个对象的多个引用,或者包含循环引用,那么我们通过特殊的路径字符串(类似于JSONPath)引用它。

// JSON.strigify replacer for objects with circ reffunction refReplacer() {let m = new Map(), v = new Map(), init = null;
return function(field, value) {let p = m.get(this) + (Array.isArray(this) ? `[${field}]` : '.' + field);let isComplex = value === Object(value)
if (isComplex) m.set(value, p);
let pp = v.get(value)||'';let path = p.replace(/undefined\.\.?/, '');let val = pp ? `#REF:${pp[0] == '[' ? '$':'$.'}${pp}` : value;
!init ? (init=value) : (val===init ? val="#REF:$" : 0);if(!pp && isComplex) v.set(value, path);
return val;}}

// ---------------// TEST// ---------------
// Generate obj with duplicate/circular referenceslet obj = {L: {L: { v: 'lorem' },R: { v: 'ipsum' }},R: {L: { v: 'dolor' },R: {L: { v: 'sit' },R: { v: 'amet' }}}}obj.R.L.uncle = obj.L;obj.R.R.uncle = obj.L;obj.R.R.L.uncle = obj.R.L;obj.R.R.R.uncle = obj.R.L;obj.L.L.uncle = obj.R;obj.L.R.uncle = obj.R;testObject = obj;
let json = JSON.stringify(testObject, refReplacer(), 4);
console.log("Test Object\n", testObject);console.log("JSON with JSONpath references\n", json);

使用类似JSONpath的引用解析此类JSON内容:

// Parse JSON content with JSONpath references to objectfunction parseRefJSON(json) {let objToPath = new Map();let pathToObj = new Map();let o = JSON.parse(json);
let traverse = (parent, field) => {let obj = parent;let path = '#REF:$';
if (field !== undefined) {obj = parent[field];path = objToPath.get(parent) + (Array.isArray(parent) ? `[${field}]` : `${field ? '.' + field : ''}`);}
objToPath.set(obj, path);pathToObj.set(path, obj);
let ref = pathToObj.get(obj);if (ref) parent[field] = ref;
for (let f in obj) if (obj === Object(obj)) traverse(obj, f);}
traverse(o);return o;}

// ---------------// TEST 1// ---------------
let json = `{"L": {"L": {"v": "lorem","uncle": {"L": {"v": "dolor","uncle": "#REF:$.L"},"R": {"L": {"v": "sit","uncle": "#REF:$.L.L.uncle.L"},"R": {"v": "amet","uncle": "#REF:$.L.L.uncle.L"},"uncle": "#REF:$.L"}}},"R": {"v": "ipsum","uncle": "#REF:$.L.L.uncle"}},"R": "#REF:$.L.L.uncle"}`;
let testObject = parseRefJSON(json);
console.log("Test Object\n", testObject);

// ---------------// TEST 2// ---------------
console.log('Tests from mathheadinclouds answer: ');
let recovered = testObject;
let obj = { // Original objectL: {L: { v: 'lorem' },R: { v: 'ipsum' }},R: {L: { v: 'dolor' },R: {L: { v: 'sit' },R: { v: 'amet' }}}}obj.R.L.uncle = obj.L;obj.R.R.uncle = obj.L;obj.R.R.L.uncle = obj.R.L;obj.R.R.R.uncle = obj.R.L;obj.L.L.uncle = obj.R;obj.L.R.uncle = obj.R;
[obj.L.L.v === recovered.L.L.v,obj.L.R.v === recovered.L.R.v,obj.R.L.v === recovered.R.L.v,obj.R.R.L.v === recovered.R.R.L.v,obj.R.R.R.v === recovered.R.R.R.v,obj.R.L.uncle === obj.L,obj.R.R.uncle === obj.L,obj.R.R.L.uncle === obj.R.L,obj.R.R.R.uncle === obj.R.L,obj.L.L.uncle === obj.R,obj.L.R.uncle === obj.R,recovered.R.L.uncle === recovered.L,recovered.R.R.uncle === recovered.L,recovered.R.R.L.uncle === recovered.R.L,recovered.R.R.R.uncle === recovered.R.L,recovered.L.L.uncle === recovered.R,recovered.L.R.uncle === recovered.R].forEach(x => console.log('test pass: ' + x));

要将生成的JSON内容加载/保存到存储中,请使用以下代码:

localStorage.myObject = JSON.stringify(testObject, refReplacer());  // SavetestObject = parseRefJSON(localStorage.myObject);                   // Load

我建议使用jackson-js。它是一个处理对象的序列化和反序列化的库,同时保留它们的结构,基于装饰器。

该库处理所有的陷阱,如循环引用、属性混淆现象等。

使用@JsonProperty()和@JsonClassType()装饰器简单地描述您的类。

使用序列化您的对象:

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

有关更详细的解释,请查看我的答案:

打字稿对象序列化?

杰克逊-js教程在这里:

Jackson js:强大的JavaScript装饰器将对象序列化/反序列化为JSON,反之亦然(第1部分)

这个问题已经从纯JavaScript的角度得到了充分的回答,其他人已经注意到localStorage.getItemlocalStorage.setItem都没有对象的概念——它们只处理字符串和字符串。这个答案提供了一个对TypeScript友好的解决方案,它结合了纯JavaScript解决方案中的其他建议

TypeScript 4.2.3

Storage.prototype.setObject = function (key: string, value: unknown) {this.setItem(key, JSON.stringify(value));};
Storage.prototype.getObject = function (key: string) {const value = this.getItem(key);if (!value) {return null;}
return JSON.parse(value);};
declare global {interface Storage {setObject: (key: string, value: unknown) => void;getObject: (key: string) => unknown;}}

用法

localStorage.setObject('ages', [23, 18, 33, 22, 58]);localStorage.getObject('ages');

补充说明

我们在Storage原型上声明了setObjectgetObject函数-localStorage就是这种类型的一个实例。除了getObject中的空处理之外,我们没有什么特别需要注意的。由于getItem可以返回null,我们必须提前退出,因为在null值上调用JSON.parse会引发运行时异常。

Storage原型上声明函数后,我们将它们的类型定义包含在全局命名空间中的Storage类型上。

注意:如果我们使用箭头函数定义这些函数,我们需要假设我们调用的存储对象总是localStorage,这可能不是真的。例如,上面的代码也将向sessionStorage添加setObjectgetObject支持。

localStorage.setItem('obj',JSON.stringify({name:'Akash'})); // Set Object in localStoragelocalStorage.getItem('obj'); // Get Object from localStorage
sessionStorage.setItem('obj',JSON.stringify({name:'Akash'})); // Set Object in sessionStoragesessionStorage.getItem('obj'); // Get Object from sessionStorage