Question

我已经从xml转换了javascript对象，这是对象的示例：

{
name: 'current name',
  attr1: 'attribute1',
  attr2: 'attribute2',
  address: {
    name: 'name1',
    value: {
      value: '12'
    },
    attr3: {
      name: 'no name',
      attr4: {
        attr4: 'attribute4'
      }
    }
  },
  price: {
    price: '500'  
  },
  in_house: {
    in_house: '2'
  }
}

我如何转换成这个：

{
name: 'current name',
  attr1: 'attr1',
  address:{
    name: 'name1',
    value: '12',
    attr3: {
      name: 'no name',
      attr4: 'attribute3'
    }
  }
  attr2: 'attr2',
  price: 500,
  in_house: 2
}

需要将所有unusefull对象转换为属性，例如 { 价钱：价格：'500' } 到 {price：'500'}

Answer 1

您可以对密钥及其值使用迭代的递归方法。

＆＃13;

function moveUp(object, last) {
    var keys = Object.keys(object);

    if (keys.length === 1 && keys[0] in last) {
        last[keys[0]] = object[keys[0]];
        if (last[keys[0]] !== null && typeof last[keys[0]] === 'object') {
            moveUp(last[keys[0]], last);
        }
        return;
    }
    keys.forEach(function (k) {
        if (object[k] !== null && typeof object[k] === 'object') {
            moveUp(object[k], object)
        }
    });
}

var object = { name: 'current name', attr1: 'attribute1', attr2: 'attribute2', address: { name: 'name1', value: { value: '12' }, attr3: { name: 'no name', attr4: { attr4: 'attribute4' } } }, price: { price: '500' }, in_house: { in_house: '2' }, test: { test: { test: { banane: 42 } } } };

moveUp(object);

console.log(object);

＆＃13;

.as-console-wrapper { max-height: 100% !important; top: 0; }

＆＃13;

Answer 2

这是一个递归函数，它将迭代根对象并传递其中的每个节点，以查看当前节点是否具有同名的直接子节点。

const obj = { name: 'current name', attr1: 'attribute1', attr2: 'attribute2',
  address: { name: 'name1', value: { value: '12' }, attr3: { name: 'no name', attr4: { attr4: 'attribute4' }}}, price: { price: '500' }, in_house: { in_house: '2' }}
// helper function to check if a value is an object
const isObject = thing => (
  typeof thing !== 'undefined' && 
  typeof thing.constructor && 
  thing.constructor === Object
)

const mutateUselessProperties = (root) => {
  // we need to recursively go through the root object and return it's result
  // after removing properties so we create an inner function for recursion
  const go = (obj) => {
    // if it's just a value return it
    if (!isObject(obj)){
      return obj
    }
    // it's an object so we loop over the keys
    for (let key in obj) {
      // check if it's an object with a child of the same key
      if (isObject(obj[key]) && obj[key][key]) {
        // reassign the property to it's child of the same name
        obj[key] = obj[key][key]
      }
      // check if it's still an object after possible reassignment
      if (isObject(obj[key])) {
        // it's an object so recrusively go through the child properties
        obj[key] = go(obj[key])    
      }
      // may as well check if we are dealing with an array at the same time
      if (Array.isArray(obj[key])) {
        obj[key] = obj[key].map(go)    
      }
    }
    // return the current iteration
    return obj
  }
  // run the recursive iteration
  go(root)
  // return the root object that has been mutated
  return root
}

console.log(mutateUselessProperties(obj))

Answer 3

如果嵌套的单个属性与父属性具有相同的名称，则以下内容应该有效;

＆＃13;

var obj = {
name: 'current name',
  attr1: 'attribute1',
  attr2: 'attribute2',
  address: {
    name: 'name1',
    value: {
      value: '12'
    },
    attr3: {
      name: 'no name',
      attr4: {
        attr4: 'attribute4'
      }
    }
  },
  price: {
    price: '500'  
  },
  in_house: {
    in_house: '2'
  }
};

for (var prop in obj) typeof obj[prop] === "object" && Object.keys(obj[prop]).length === 1 && (obj[prop] = obj[prop][prop]);
console.log(obj);

＆＃13;

将具有一个属性的对象转换为父属性

3 个答案: