使用js如何转换这种数据结构？

Question

要将这个数据：

[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]

转换成如下数据结构：

{
  THEDTAE: ['2023-05-09','2023-05-10'],
  QTYPE: 1,
  UNITTYPE: 2
}

请教下如何实现？

Answer 1

const str = "[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]";
const arr = str.split("|");

const reg = /\[(.+?)\]/g;;

const obj = arr.reduce((obj, item) => {
  const match = [...item.matchAll(reg)];
  if (match.length) {
    obj[match[0][1]] = match.length > 2
      ? match.slice(1).map(item => item[1])
      : match[1] && match[1][1]
  }
  return obj;
}, {});

console.log(obj, "obj")
// { THEDTAE: [ '2023-05-09', '2023-05-10' ], QTYPE: '1', UNITTYPE: '2' } obj

Answer 2

function transform(str) {
    var ret = {};
    var reg = /\[(.+?)\]/g;
    var arr = str.split("|");
    for (var i = 0; i < arr.length; ++i) {
        var match, key, value = [];
        while (match = reg.exec(arr[i])) value.push(match[1]);
        if (key = value.shift()) {
            if (value.length <= 1) value += "";
            ret[key] = value;
        }
    }
    return ret;
}
console.log(transform("[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]"));

Answer 3

const str = '[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]';

// 使用正则表达式解析原始字符串
const reg = /\[(\w+)\]\[([\d-]+)\]/g;
let match;
const result = {};
while ((match = reg.exec(str))) {
  const key = match[1];
  const value = match[2];
  if (result[key]) {
    result[key].push(value);
  } else {
    result[key] = [value];
  }
}

// 将解析后的数据组装成目标数据结构
const output = {};
for (const [key, value] of Object.entries(result)) {
  if (value.length === 1) {
    output[key] = value[0];
  } else {
    output[key] = value;
  }
}

console.log(output);

const str = '[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]';
const obj = {}

str.split('|').forEach(item => {
    var list = item.match(/\[[^\[\]]*\]/g).map(i=>i.replace(/[\[\]]/g, ''))
    var key = list[0]
    var valArr = list.slice(1)
    var val = valArr.length>1?valArr:valArr[0]
    obj[key] = val
})
console.log(obj)

Answer 4

方法一：

const data = "[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]";

// 解析数据
const dataArray = data.split("|");

// 使用Map数据结构来存储转换后的数据
const convertedData = new Map();

// 遍历数据数组
dataArray.forEach(item => {
  // 提取标签和值
  const [label, value] = item.replace("[", "").split("]");

  // 使用解构赋值和Map的特性来添加值到转换后的数据对象中
  if (convertedData.has(label)) {
    // 如果标签已经存在，则将值添加到数组中
    convertedData.get(label).push(value);
  } else {
    // 如果标签不存在，则创建一个新的数组并添加值
    convertedData.set(label, [value]);
  }
});

// 将Map数据结构转换为普通对象
const convertedObject = Object.fromEntries(convertedData);

console.log(convertedObject);

方法二：

const data = "[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]";

// 解析数据
const dataArray = data.split("|");

// 创建一个空对象来存储转换后的数据
const convertedData = {};

// 遍历数据数组
dataArray.forEach(item => {
  // 提取标签和值
  const [label, value] = item.replace("[", "").split("]");

  // 根据标签将值添加到转换后的数据对象中
  if (convertedData[label]) {
    // 如果标签已经存在，则将值添加到数组中
    convertedData[label].push(value);
  } else {
    // 如果标签不存在，则创建一个新的数组并添加值
    convertedData[label] = [value];
  }
});

console.log(convertedData);

ts写法

const data: string = "[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]";

// 解析数据
const dataArray: string[] = data.split("|");

// 使用Map数据结构来存储转换后的数据
const convertedData: Map<string, string[]> = new Map();

// 遍历数据数组
dataArray.forEach((item: string) => {
  // 提取标签和值
  const [label, value]: string[] = item.replace("[", "").split("]");

  // 使用解构赋值和Map的特性来添加值到转换后的数据对象中
  if (convertedData.has(label)) {
    // 如果标签已经存在，则将值添加到数组中
    convertedData.get(label)?.push(value);
  } else {
    // 如果标签不存在，则创建一个新的数组并添加值
    convertedData.set(label, [value]);
  }
});

// 将Map数据结构转换为普通对象
const convertedObject: { [key: string]: string[] } = Object.fromEntries(convertedData);

console.log(convertedObject);

Answer 5

const data = "[THEDTAE][2023-05-09][2023-05-10]|[QTYPE][1]|[UNITTYPE][2]";

const extract = (str) => {
    let left = 0;
    let right = 0;

    let result = [];
    let tmp = "";
    for (let i = 0; i < str.length; i++) {
        const item = str[i];
        if (left === 1 && right === 1) {
            result.push(tmp);
            tmp = "";
            left = 0;
            right = 0;
        }
        if (item === "[") {
            left = 1;
        } else if (item === "]") {
            right = 1;
        } else {
            tmp += item;
        }
    }
    result.push(tmp);
    return result;
};

function parse(str) {
    const result = str.split("|");
    let rsOb = {};
    result.forEach((item) => {
        const list = extract(item);
        let ob = {};
        ob[list.shift()] = list.length === 1 ? list[0] : list;
        rsOb = { ...rsOb, ...ob };
    });
    return rsOb;
}

console.log(parse(data));

Answer 6

function decode(s) {
    function takeKeyValue(s) {
        const [tagMatch, ...valueMatchArray] = Array.from(s.matchAll(/\[(.+?)\]/g));
        const [, tag] = tagMatch;
        const valueArray = valueMatchArray.map(([, x]) => x);

        if (1 < valueArray.length) {
            return [tag, valueArray.map(decodeValue)]
        } else {
            return [tag, decodeValue(valueArray[0])];
        }
    }

    function decodeValue(x) {
        const numberValue = Number(x)
        if (Number.isNaN(numberValue)) {
            return x;
        } else {
            return numberValue;
        }
    }

    const keyValueArray = s.split('|').map(takeKeyValue);
    return Object.fromEntries(keyValueArray);
}