逻辑思路

请求一个方法，可能成功，可能失败。若失败，最多自动请求三次，若仍为失败，则结束。

function Random() {
	return num = parseInt(Math.random()*10);
}
function Request(count = 1) {
	let num = Random();
	if(num % 2 == 0){
		console.log('失败第'+ count + '次');
		count++;
		if(count <= 3){
			Request(count);
		}
		return false;
	}else{
		return true;
	}
}
Request()

一个数组里面有n个函数，第一个函数的返回值作为参数传给第二个函数，第二个函数的返回值作为参数传给第三个函数

function f1(){
    console.log('f1接受到的值:')
    return 'f1'
    
}
function f2(f1){
    console.log('f2接受到的值:'+ f1)
    return 'f2'
    
}
function f3(f2){
    console.log('f3接受到的值:'+ f2)
    return 'f3'
    
}
function f4(f3){
    console.log('f4接受到的值:'+ f3)
    return 'f4'
    
}
function test(index = 0, result) {
	let arr = [f1, f2, f3, f4];
	let value = arr[index](result);
	index++;
	if(index < arr.length){
		test(index,value);
	}
}
test(0, '')

解析树状结构

var treeList = {
        text: '1',
        children:[
            {
                text: '1-1',
                children: [
                    {
                        text: '1-1-1'
                    },
                    {
                        text: '1-1-2'
                    }
                ]
            },
            {
                text: '1-2',
                children: [
                    {
                        text: '1-2-1'
                    },
                    {
                        text: '1-2-2'
                    }
                ]
            }
        ]
    }
    function getText(obj) {
        console.log(obj.text);
        if(Reflect.has(obj,'children')){
            let childrenList = obj.children;
            let len = childrenList.length;
            for(var i = 0; i < len; i++){
                getText(childrenList[i]);
            }
        }
    }
getText(treeList);

将字符串解析成数据结构

//   let str = '1-1-1-1';
//   let obj = [{
//         text: '1',

//         children: [
//             {
//                 text: '1-1',

//                 children: [
//                     {
//                         text: '1-1-1',

//                         children: [
//                             {
//                                text: '1-1-1-1',
//                             }
//                         ]
//                     }
//                 ]
//             }
//         ]
//     }]
//关键：找一个第三变量来记录上一次的结构（引用赋值：指向同一处地址，一处改变，所有都改变）

//解法一：以数组为规律
    function test(str){
            let arr = str.split('-'); 
            let result = [];
            let obj = {};
            let j = 1;
            obj.text = str.substr(0,j);
            let currentArr = [];  
            result.push(obj);
            for(var i = 0; i < arr.length - 1; i++){
                j = j + 2;
                let childrenArr = [];
                let childrenObj = {};
                childrenArr.push(childrenObj);
                childrenObj.text = str.substr(0,j);
                if( i == 0 ){
                    obj.children = childrenArr;
                }else{
                    currentArr[0].children = childrenArr;  
                }  
                currentArr = childrenArr;
            }
            console.log(result);
    }
    test(str);

//解法二：以对象为规律
function test(str){
            let resultArr = [];
            let arr = str.split('-');
            let curChildren = [];
            let result = {}; 
            let j = 1;
            for(var i = 0; i < arr.length; i++){
                let obj = {};
                obj.text = str.substr(0,j);
                obj.children = [];
                if(i == 0){
                    result = obj;
                }else{
                    curChildren.push(obj);
                }
                j = j + 2;
                curChildren = obj.children;
            }
			resultArr.push(result);
            return resultArr;
}
        test(str)