这两个方法花了一天的时间写出来的，记录一下以免弄丢了

• 级联数组转换为字符串数组

parseDataToCascader(insertArr) {
        let returnArr = []; // 最后返回的数组
        let mapList = {}; // 保存级联关联状态的对象
        let itemLength = []; // 保存数组的length长度, 取出最大值
        // 遍历数组 获取到级联名称 EP: item => '一级1-二级1-三级1'
        for (let item of insertArr) {
          // 获取 级联 名称数组 EP: itemsArr => ['一级1', '二级1', '三级1']
          let itemsArr = item.split('-');

          // 遍历层级名称数组 获取当前级联层级名称 EP: key => '一级1'
          for (let key of itemsArr) {
            // sort 区分级联的层级 EP: sort => 0
            let sort = itemsArr.indexOf(key);
            if (itemsArr.length > 1) {
              // 处理数据
              getMapList(sort, itemsArr);
            }
          }

          // 将数组的length取出组成新的数组取出最大值
          itemLength.push(itemsArr.length);
        }

        if (itemLength.length > 0) {
          itemLength.sort((a, b) => {
            return a - b;
          });
          this.formData.isCascade = itemLength[itemLength.length - 1];
        }


        /**
         * 处理数据的外层函数 为子递归提供参数遍历参数
         * @param {Number} sort 当前级联层级 EP: sort => 0
         * @param {Array} itemsArr 当前级联数组 EP: itemsArr => ['一级1', '二级1', '三级1']
         */
        function getMapList(sort, itemsArr) {
          // 保存当前级联层级
          let _sort = sort;
          // 递归次数 用于建立级联关联状态
          let i = -1;

          // 开始赋值
          assignValueToArray(mapList, returnArr);

          /**
           * 递归调用 循环赋值
           * @param {Object} mapObj 级联关系对象
           * @param {Array} rtnArr 当前级联对象对应的实际数组
           */
          function assignValueToArray(mapObj, rtnArr) {
            // 递归次数 + 1 用于 sort !== 0 时 获取实际级联关系对象
            i += 1;

            // 如果级联层级 === 0 进行赋值操作
            if (sort === 0) {
              // 当前级联对象已存在的关联关系数组
              let existedKeys = Object.keys(mapObj);
              // 当前级联名称
              let _value = itemsArr[_sort];

              // 不存在关系则建立关系并赋值
              if (existedKeys.indexOf(_value) === -1) {
                // 建立级联关系匹配对应数组的 index 值
                mapObj[_value] = {
                  key: Number(existedKeys.length)
                };

                // 建立赋值对象
                let appendObj = {
                  value: _value,
                  label: _value
                };

                // 为非最底层级联添加 children 对象
                if (_sort !== itemsArr.length - 1) {
                  mapObj[_value].children = {};
                  appendObj.children = [];
                }

                // 数组赋值
                rtnArr[mapObj[itemsArr[_sort]].key] = appendObj;
              }
            } else {
              // 如果级联层级 !== 0 递归调用自身 传递下一级级联的关系和数组 初始 i 值为 0;
              sort -= 1;
              // 递归调用自身
              assignValueToArray(mapObj[itemsArr[i]].children, rtnArr[mapObj[itemsArr[i]].key].children);
            }
          }
        }

        console.log(returnArr);
        // 返回处理后的数组
        return returnArr;
      }

• 字符串数组转换为级联数组

cascaderToParseData: function (data) {
        let result = []; // 最终返回的数组
        let INDEX = 0;
        let flattenArray = (list, array, index) => {
          let items = array || [];
          index ++;
          list.forEach(item => {
            if (items.length < index) {
              items.splice(index - 1, 0, item.label);
            } else {
              items.splice(index - 1, 1, item.label);
            }
            if (item.children) {
              flattenArray(item.children, items, index);
            } else {
              result.push(items.join('-'));
            }
          });
        };
        flattenArray(data, [], INDEX);
        return result.join('\n');
      }