这个问题已经从仅JavaScript的角度得到了充分的回答，其他人已经注意到localStorage.getItem和localStorage.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原型上声明setObject和getObject函数，localStorage就是这种类型的实例。除了getObject中的空处理之外，我们真的没有什么特别需要注意的。由于getItem可以返回null，我们必须提前退出，因为对null值调用JSON.parse将引发运行时异常。

在存储原型上声明函数之后，我们将其类型定义包含在全局命名空间中的存储类型上。

注意：如果我们用箭头函数定义这些函数，我们需要假设我们调用的存储对象总是localStorage，这可能不是真的。例如，上述代码还将向sessionStorage添加setObject和getObject支持。

我在读到另一篇文章后发表了这篇文章，这篇文章的标题是“如何在本地存储中存储数组？”。这很好，除了两个线程都没有提供关于如何在localStorage中维护数组的完整答案之外，不过我已经根据两个线程中包含的信息制定了一个解决方案。

因此，如果其他人希望能够在数组中推送/弹出/移动项目，并且他们希望将该数组存储在localStorage或sessionStorage中，那么可以这样做：

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');

示例用法-在sessionStorage阵列中存储对象：

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

理论上，可以使用以下函数存储对象：

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;
}

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

循环引用

在这个答案中，我专注于具有循环引用的仅数据对象（没有函数等），并开发maja和mathheadinclouds提到的想法（我使用了他的测试用例和我的代码短了几倍）。

实际上，我们可以使用带有适当替换符的JSON.stringify-如果源对象包含对某个对象的多个引用，或者包含循环引用，那么我们可以通过特殊路径字符串（类似于JSONPath）来引用它。

//JSON.strify具有circ-ref的对象的替换器函数refReplacer（）{设m=new Map（），v=new Map），init=null；返回函数（字段，值）{让p=m.get（this）+（Array.isArray（this）`[$｛field｝]“：”.“+字段）；让isComplex=value==对象（值）如果（isComplex）m.set（值，p）；让pp=v.get（value）||''；let path=p.replace（/未定义\.\？/，“”）；让val=pp`#REF:$｛pp[0]==“[”？“$”：“$.”｝$｛pp｝“：value；!初始化？（init=value）：（val===init？val=“#REF:$”：0）；if（！pp&&isComplex）v.set（value，path）；返回值；}}// ---------------//测试// ---------------//生成具有重复/循环引用的obj让obj={我：{五十： {v:“lorem”}，R： ｛v:“ipsum”｝},R：{五十： ｛v:“dolor”｝，R：{五十： {v:“坐”}，R： ｛v:“amet”｝}}}obj.R.L.uncle=对象L；obj.R..uncle=对象L；obj.R.L..uncle=obj.R.L；obj.R.R..uncle=obj.R.L；obj.L.L.uncle=对象R；obj.L.R.unncle=对象R；testObject=obj；让json=json.stringify（testObject，refReplacer（），4）；console.log（“测试对象\n”，testObject）；console.log（“带有JSONpath引用的JSON”，JSON）；

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

//使用对象的JSONpath引用解析JSON内容函数parseRefJSON（json）{let objToPath=新映射（）；let pathToObj=新映射（）；let o=JSON.parse（JSON）；让遍历=（父级，字段）=>{让obj=父级；let path=“#REF:$”；if（字段！==未定义）{obj=父[字段]；path=objToPath.get（父）+（Array.isArray（父）`[$｛field｝]`：`$｛field？'。'+字段：''｝`）；}objToPath.set（obj，路径）；pathToObj.set（路径，对象）；let ref=路径目标获取（obj）；如果（ref）父[字段]=ref；for（让f在obj中）if（obj==对象（obj））遍历（obj，f）；}横向（o）；返回o；}// ---------------//测试1// ---------------让json=`{“L”：{“L”：{“v”：“lorem”，“叔叔”：{“L”：{“v”：“dolor”，“叔叔”：“#REF:$.L”},“R”：{“L”：{“v”：“坐”，“叔叔”：“#REF:$.L.L叔叔.L”},“R”：{“v”：“amet”，“叔叔”：“#REF:$.L.L叔叔.L”},“叔叔”：“#REF:$.L”}}},“R”：{“v”：“ipsum”，“叔叔”：“#REF:$.L.L叔叔”}},“R”：“#REF:$.L.L叔叔”}`;let testObject=parseRefJSON（json）；console.log（“测试对象\n”，testObject）；// ---------------//测试2// ---------------console.log（'来自mathheadinclouds的测试答案：'）；let recovered=测试对象；let obj={//原始对象我：{五十： {v:“lorem”}，R： ｛v:“ipsum”｝},R：{五十： ｛v:“dolor”｝，R：{五十： {v:“坐”}，R： ｛v:“amet”｝}}}obj.R.L.uncle=对象L；obj.R..uncle=对象L；obj.R.L..uncle=obj.R.L；obj.R.R..uncle=obj.R.L；obj.L.L.uncle=对象R；obj.L.R.unncle=对象R；[目标L.L.v===恢复L.L.v，目标L.R.v===恢复L.R.v，目标R.L.v===恢复的R.L.v，目标R.R.L.v===恢复的R.R.L.v，obj.R.R.R.v===恢复的R.R.R.v，obj.R.L.包含==obj.L，对象.R.R.uncle==对象L，obj.R.L.包含==obj.R.L，obj.R.R.包含==obj.R.L，对象.L.L.uncle==对象R，obj.L.R.包含==obj.R，recovered.R.L叔叔==已恢复.L，恢复.R.R.叔叔==恢复.L，恢复.R.R.L叔叔==恢复.R.L，恢复.R.R.R.叔叔==恢复.R.L，recovered.L.L叔叔==恢复。R，已恢复.L.R叔叔==已恢复.R].forEach（x=>console.log（'测试通过：'+x））；

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

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

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对象

再次查看Apple、Mozilla和Mozilla文档，功能似乎仅限于处理字符串键/值对。

解决方法是在存储对象之前将其字符串化，然后在检索对象时对其进行解析：

var testObject = { 'one': 1, 'two': 2, 'three': 3 };

// Put the object into storage
localStorage.setItem('testObject', JSON.stringify(testObject));

// Retrieve the object from storage
var retrievedObject = localStorage.getItem('testObject');

console.log('retrievedObject: ', JSON.parse(retrievedObject));