如何用递归让自定义JSON.stringify函数支持嵌套数组与对象

你自己实现了一个能处理基础类型、简单数组和对象的stringifier函数，但无法处理嵌套数组/对象，想通过递归解决这个问题，同时确认实现思路是否正确。

你的原代码：

function stringifier (input) {
  
  let output = '';
  
  if (typeof input === 'number'){
   output+= input
 }else if (input === undefined){
   output = undefined
 }else if (input === null){
 output += 'null'
 }else if (typeof input === 'string'){
   output += `\"${input}\"`
 }else if(typeof input === 'function'){
 output = undefined
 }
 
 else if (Array.isArray(input)){
   output+='['
   for (let i =0 ; i < input.length ; i++){
     if (typeof input[i] === 'string'){
     output += `\"${input[i]}\",`
     }else if(typeof input[i]=== 'number'){
       output += `${input[i]},`
     }else if(input[i] === null || typeof input[i] === 'function' || input[i]=== undefined){
       output += 'null,'
     }
   }output = output.substring(0,output.length-1)
   output += ']'}
 
 else if(Array.isArray(input)=== false && typeof input === 'object'){
 output+='{'
 for (let [key, value] of Object.entries(input)) {
   
   if (typeof value === 'string'){
  output += `\"${key}\":\"${value}\",`
   }else if (typeof value === 'number'){
     output += `\"${key}\":${value},`
   }else if (value === null){
     output += `\"${key}\":null,`
   }
   
 }output = output.substring(0,output.length-1) 
 output += '}';}

 return output
}

解决方案：通过递归支持嵌套结构 #

你的实现思路完全没问题，核心问题是没有对嵌套的数组/对象元素递归调用处理函数。只需要把数组元素、对象属性值的处理逻辑，从重复判断类型拼接，改成调用stringifier自身，就能自动处理任意层级的嵌套结构。

修改后的代码：

function stringifier(input) {
  // 处理基础类型
  if (typeof input === 'number') {
    return String(input);
  }
  if (input === undefined || typeof input === 'function') {
    return 'null'; // JSON标准中不支持undefined和函数，数组中转为null
  }
  if (input === null) {
    return 'null';
  }
  if (typeof input === 'string') {
    return `"${input}"`;
  }

  // 处理数组：递归处理每个元素
  if (Array.isArray(input)) {
    const elements = input.map(item => stringifier(item));
    return `[${elements.join(',')}]`;
  }

  // 处理普通对象：递归处理每个属性值，可选过滤JSON不支持的键值对
  if (typeof input === 'object') {
    const entries = Object.entries(input)
      // 严格符合JSON标准：过滤值为undefined/函数的键
      .filter(([_, value]) => value !== undefined && typeof value !== 'function')
      .map(([key, value]) => `"${key}":${stringifier(value)}`);
    return `{${entries.join(',')}}`;
  }

  // 其他未定义类型默认返回null
  return 'null';
}

关键修改说明 #

1. 递归调用：数组的每个元素、对象的每个属性值，都通过stringifier(item)递归处理，自动适配嵌套数组、嵌套对象甚至混合嵌套的场景。
2. 简化字符串拼接：用map+join替代手动循环拼接，避免手动处理逗号时的边界错误（比如空数组/空对象不会出现语法问题）。
3. 贴合JSON标准：可选过滤对象中值为undefined或函数的键（这是JSON.stringify的默认行为），数组中的这类值转为null。

关于你的实现思路 #

你的核心思路完全正确——先判断基础类型，再处理容器类型（数组、对象），只是缺少了递归处理嵌套结构的环节。修改后复用自身函数处理每个子元素，就能自然支持任意层级的嵌套。

内容的提问来源于stack exchange，提问作者Matt Kelsey