递归 JSON.stringify 实现

我正在尝试学习 Javascript 中的递归，所以我想我应该重写本机JSON.stringify使用递归函数作为对自己的挑战。我几乎让我的代码可以工作：

var my_stringify = function(obj){        
  value = obj[ Object.keys(obj)[0] ];
  index = Object.keys(obj)[0];

  delete obj[ Object.keys(obj)[0] ];

  // The value is just a simple string, not a nested object
  if (typeof value === 'string'){
    if (Object.keys(obj).length !== 0){
      // Continue recursion ..
      return '"' + index + '":"' + value + '",' + my_stringify(obj);
    }

    // This would be the base case with a string at the end. Stop recursion.
    return '"' + index + '":"' + value + '"}';
  }
  // The value is actually a nested object
  else{     
    if (Object.keys(obj).length !== 0){
    // Continue recursion ..
      return '"' + index + '":{' + my_stringify(value) + ',' + my_stringify(obj);
    }
    // This is the base case with a nested object at the end. Stringify it and end recursion.
    return '"' + index + '":{' + my_stringify(value) + '}';  
  }
}

除了第一个事实之外{我的答案中缺少，我不知道如何修复这个错误。

E.g. my_stringify({foo: 'bar'})回报"foo":"bar"}代替{"foo":"bar"}.

另外，我知道我完全破坏了原始对象，有什么方法可以将原始对象的简化版本发送到递归而不删除任何内容（例如obj.slice(1))?

任何建议将不胜感激！

老问题的新答案

这里有一些非常糟糕的答案，即使在最简单的例子下也失败了。这个答案旨在详尽地回答这个问题，并演示即使在处理各种数据类型时，这样的方法也如何扩展......

极端情况

该函数对非空数据进行简单的案例分析constructor属性并进行相应编码。它设法涵盖了许多您不太可能考虑的极端情况，例如

• JSON.stringify(undefined)回报undefined
• JSON.stringify(null)回报'null'
• JSON.stringify(true)回报'true'
• JSON.stringify([1,2,undefined,4])回报'[1,2,null,4]'
• JSON.stringify({a: undefined, b: 2})回报'{ "b": 2 }'
• JSON.stringify({[undefined]: 1})回报'{ "undefined": 1 }'
• JSON.stringify({a: /foo/})回报{ "a": {} }

所以为了验证我们的stringifyJSON函数实际上工作正常，我不打算直接测试它的输出。相反，我要写一点test方法，确保JSON.parse我们编码的 JSON 实际上返回了我们的原始输入值

// we really only care that JSON.parse can work with our result
// the output value should match the input value
// if it doesn't, we did something wrong in our stringifier
const test = data => {
  return console.log(JSON.parse(stringifyJSON(data)))
}

test([1,2,3])     // should return [1,2,3]
test({a:[1,2,3]}) // should return {a:[1,2,3]}

免责声明：很明显我要分享的代码是并不意味着用作实际替代品 for JSON.stringify– 有无数的极端情况我们可能没有解决。相反，共享此代码是为了演示我们如何完成此类任务。可以轻松地将其他极端情况添加到此函数中。

可运行的演示

话不多说，这里是stringifyJSON在可运行的演示中验证了几种常见情况的出色兼容性

const stringifyJSON = data => {
  if (data === undefined)
    return undefined
  else if (data === null)
    return 'null'
  else if (data.constructor === String)
    return '"' + data.replace(/"/g, '\\"') + '"'
  else if (data.constructor === Number)
    return String(data)
  else if (data.constructor === Boolean)
    return data ? 'true' : 'false'
  else if (data.constructor === Array)
    return '[ ' + data.reduce((acc, v) => {
      if (v === undefined)
        return [...acc, 'null']
      else
        return [...acc, stringifyJSON(v)]
    }, []).join(', ') + ' ]'
  else if (data.constructor === Object)
    return '{ ' + Object.keys(data).reduce((acc, k) => {
      if (data[k] === undefined)
        return acc
      else
        return [...acc, stringifyJSON(k) + ':' + stringifyJSON(data[k])]
    }, []).join(', ') + ' }'
  else
    return '{}'
}

// round-trip test and log to console
const test = data => {
  return console.log(JSON.parse(stringifyJSON(data)))
}

test(null)                               // null
test('he said "hello"')                  // 'he said "hello"'
test(5)                                  // 5
test([1,2,true,false])                   // [ 1, 2, true, false ]
test({a:1, b:2})                         // { a: 1, b: 2 }
test([{a:1},{b:2},{c:3}])                // [ { a: 1 }, { b: 2 }, { c: 3 } ]
test({a:[1,2,3], c:[4,5,6]})             // { a: [ 1, 2, 3 ], c: [ 4, 5, 6 ] }
test({a:undefined, b:2})                 // { b: 2 }
test({[undefined]: 1})                   // { undefined: 1 }
test([[["test","mike",4,["jake"]],3,4]]) // [ [ [ 'test', 'mike', 4, [ 'jake' ] ], 3, 4 ] ]