var nest_result=[];
function arrNestToNonNest(arr){

for(let item of arr){
    nest_result.shift({"id":item.id,"title":item.title})
    if(item.hasOwnProperty("child")){
        arrNestToNonNest(item.child)
    }
}

}
arrNestToNonNest(data)

可能并不是最優(yōu)，但很清真（跑

function flattern(data) {
  return data.reduce((iter, val) => {
    let {id, title} = val;
    let com_arr = [...iter, {id, title}];
    return val.child ? [...com_arr, ...flattern(val.child)] : com_arr;
  }, []);
}

let result = flattern(data);
console.log(result);

大概就是個廣度優(yōu)先算法嘛...

var result = [];    // 存放結果
var queue = [data]; // 用于遍歷
var item;           // 臨時值
// 從隊列里取出要轉換的數(shù)據(jù)數(shù)組
while (item = queue.shift()) {
    item.forEach(i => {
        // 遍歷數(shù)組，轉換數(shù)據(jù)，放入結果中
        result.push({
            id: i.id,
            title: i.title,
        });
        // 如果有子數(shù)據(jù)的，放到隊列最后等待處理
        i.child && queue.push(i.child);
    })
}

emm...看了下評論是需要深度遍歷...都寫上吧。

var result = [];    // 存放結果
(function traverse(node) {
    node.forEach(i => {
        result.push({
            id: i.id,
            title: i.title,
        });
        // 有子數(shù)據(jù)的先遍歷子數(shù)據(jù)
        i.child && traverse(i.child)
    })
})(data);

樓上的方法都不錯了，這個性能也就這樣的。

這是一個遍歷樹型結構的問題，可以參閱：使用遞歸遍歷并轉換樹形數(shù)據(jù)，文中講到了用遞歸實現(xiàn)的深度遍歷，也講到了用隊列實現(xiàn)的廣度遍歷。

深度遍歷和廣度遍歷的結果順序會有所不同，樓上兩位都是遞歸實現(xiàn)（深度），下面給個廣度的示例：

function gothrough(data) {
    const queue = [...data];
    const result = [];
    while (true) {
        const next = queue.shift();
        if (!next) {
            break;
        }
        result.push({
            id: next.id,
            title: next.title
        });
        if (Array.isArray(next.child)) {
            queue.push(...next.child);
        }
   }

   return result;
}

代碼還可以簡潔一些，但性能可能會略差一點

function gothrough(data) {
    let next = [...data];
    const result = [];
    while (next.length) {
        result.push(...next.map(m => ({ id: m.id, title: m.title })));
        next = next
            .filter(m => Array.isArray(m.child))
            .reduce((all, m) => [...all, ...m.child], []);
    }
    return result;
}

(function(_data,_list){
    function t_whill(data){
        for(let info of data){
            if('child' in info){
                t_whill(info['child']);
                delete info['child'];
            }
            _list.push(info);
        }
    }
    t_whill(_data,_list);
    log(_list);
})(data,[]);

function TreeToArray(data,list) {
    var i = 0, len = data.length, list = list || [];
    for (; i < len;) {
        var item = data[i++], child = item.child;
        if (child) {
            delete item.child;
            list.push(item);
            arguments.callee(child, list);
        } else {
            list.push(item);
        }
    }
}

var list = [];
TreeToArray(data, list);
console.log(JSON.stringify(list));