Question

我想迭代对象并将数字转换为字符串，但我不知道属性的名称以及嵌套的数量，例如：

var a = {
    a: 1,
    b: {
       a: 2
    }
}

结果应为：

var a = {
    a: "1",
    b: {
       a: "2"
    }
}

我想我需要一个递归函数

Answer 1

您可以实现一个递归函数，它将迭代对象的所有属性，并且：

将每个number属性转换为字符串
为每个object属性

＆＃13;

var a = {
    a: 1,
    b: {
       a: 2
    }
};

function convert(o)
{
  for (var k in o)
  {
    if (!o.hasOwnProperty(k)) continue; 

    switch (typeof o[k])
    {
      case 'number':
        o[k] = o[k].toString();
        break;
      case 'object':
        convert(o[k]); 
        break;
    }
  }
}

convert(a);

document.querySelector('pre').innerText = JSON.stringify(a, null, 4);

＆＃13;

<pre></pre>

＆＃13;

Answer 2

我更喜欢尽可能避免副作用。因此，递归地创建新对象并最终返回新创建的对象，如此

function rec(obj) {
  if (typeof obj === 'object') {
    var result = {};

    // iterate all the keys of the object
    for (key in obj) {

      // if the key is only defined on this object, not inherited
      if (obj.hasOwnProperty(key)) {

        // then recursively reconstruct the objects
        result[key] = rec(obj[key]);
      }
    }
    return result;
  }

  // if it is not an object, then stringify it and return.
  return '' + obj;
}

console.log(rec(a));
// { a: '1', b: { a: '2' } }

Answer 3

这样的东西（需要引擎支持默认参数）。

＆＃13;

function walk(o, action, index = 0, keys = Object.keys(o)) { 
  var item;

  if (index > keys.length) {
    return null; // End of siblings.
  }

  item = o[keys[index]];      

  if(item !== null && typeof item === 'object') { // null is an object.
    walk(item, action); // Children.
  } else {
    o[keys[index]] = action(item);
  }

  return walk(o, action, ++index); // Siblings.
}

var o = { foo: 1, bar: { bam: 2 } };
walk(o, p => (typeof p === 'number') && p.toString());

document.write('o.foo is now a ', typeof o.foo); // 'string'
document.write('<br/>');
document.write('o.bar.bam is now a ', typeof o.bar.bam); // 'string'

＆＃13;

Answer 4

您可以编写一个简单的递归函数来执行以下操作：

检查当前属性是否为Object。
如果是的话 - >递归调用相同的函数来遍历嵌套对象的属性。
如果当前属性不是对象 - ＆gt;检查是否可以将值解析为数字。

如果发生NaN，则保存原始值，否则保存已解析的数字。

function convertToNumber(obj) {
for(var prop in obj) {
    if(obj[prop] instanceof Object) {
        //If the current property is an object
        //calls itself recursively over it's props
        convertToNumber(obj[prop]);
    } else {
        //Like Try-Parse, it will return NaN if item
        //cannot be converted to number
        var temp = Number(obj[prop]);
        //Checks if the temporary variable is a valid number or NaN
        //If it's value is NaN it keeps the original value
        obj[prop] = !isNaN(temp) ?  temp : obj[prop] ;
    }
}
}

迭代属性对象

4 个答案: