Преобразование массива строк в массив объектов, где каждая строка имеет разделитель

Question

У меня есть массив строк:

["aa-q1-true", "bb-q1-false", "cc-q1-true", "aa-q2-true", "xx-q2-false", "yy-q2-true", "mm-q3-true", "mn-q3-false", "qr-q3-false"]

Где каждая строка имеет значение. Например, если мы рассмотрим первую строку, т.е. "aa-q1-true" Здесь первая часть - aa - это ответ викторины, средняя часть - q1 - это вопрос, а true - последняя часть - это статус ответа. Статус может быть true или false. Это правило применяется для каждой строки внутри массива.

Теперь я хочу преобразовать его в массив объектов, подобных следующему:

[
    0: [{
        quizAns: [{aa: true}, {bb: false}, {cc: true}]
        quizQuestion: q1
    }]

    1: [{
        quizAns: [{aa: true}, {xx: false}, {yy: true}]
        quizQuestion: q2
    }]

    2: [{
        quizAns: [{mm: true}, {mn: false}, {qr: false}]
        quizQuestion: q3
    }]
]

Я просто не мог понять logi c, чтобы сделать это самостоятельно. Если вы можете просто предложить несколько идей или решений, это будет очень полезно. Большое спасибо за ваше время.

Answer 1

Вам нужно разделить каждый элемент на -, а затем вы получите первый и последний элемент, чтобы получить объект ответа, и середину, чтобы узнать, к какому вопросу он принадлежит, затем вы просто итеративно создаете решение:

let ans = ["aa-q1-true", "bb-q1-false", "cc-q1-true", "aa-q2-true", "xx-q2-false", "yy-q2-true", "mm-q3-true", "mn-q3-false", "qr-q3-false"].map((s) => s.split('-')).reduce((carry, current) => {
    let existingIndex = carry.findIndex((item) => item.quizQuestion === current[1]);
    if (existingIndex === -1) {
        carry.push({quizAns: [], quizQuestion: current[1]});
        existingIndex = carry.length - 1;
    }
    carry[existingIndex].quizAns.push({[current[0]]: current[2]});
    return carry;
}, []);

console.log(ans);

Answer 2

Еще один подход с меньшим количеством кода

const resultMap = array.reduce((acc, item) => {
  // current data
  const [answer, quizQuestion, status] = item.split("-");
  // previous answers
  const previousAnswers = acc[quizQuestion] ? acc[quizQuestion].quizAns : [];
  // new answers
  const newAnswers = [...previousAnswers, { [answer]: status }];
  return { ...acc, [quizQuestion]: { quizQuestion, quizAns: newAnswers } };
}, {});

const result = Object.values(resultMap) 
console.log(result)

Answer 3

Я не большой поклонник array.reduce синтаксической причины фактора удобочитаемости.

Этот l oop будет работать, даже если ввод идет в зашифрованном виде.

const a = ["aa-q1-true", "bb-q1-false", "cc-q1-true", "aa-q2-true", "xx-q2-false", "yy-q2-true", "mm-q3-true", "mn-q3-false", "qr-q3-false"];let results = [];

const retObj = (que, ans) => {
  const obj = {};
  obj[`${que}`] = ans;
  return obj;
};

for (let i in a){
  let currEleArr = a[i].split("-");
  let tarInd = parseInt(currEleArr[1].split("")[1]) - 1;
  let que = currEleArr[0];
  let ans= currEleArr[2];

  if (!results[tarInd])
    results[tarInd] = [{quizAns: []}];
  
  if(!results[tarInd][0].quizQuestion) 
  results[tarInd][0]["quizQuestion"] = `q${tarInd + 1}`;
  
  results[tarInd][0].quizAns.push(retObj(que, ans));
   
}

console.log(results);

Answer 4

Просто другой подход. Имеет меньшее количество циклов по массиву, чем другой ответ.

let questions = {  };
let ans = ["aa-q1-true", "bb-q1-false", "cc-q1-true", "aa-q2-true", "xx-q2-false", "yy-q2-true", "mm-q3-true", "mn-q3-false", "qr-q3-false"]
            .reduce((acc, curr) => {
                let elements = curr.split("-");
                let obj = {};
                obj[elements[0]] = elements[2];

                if (questions[elements[1]]) {
                    questions[elements[1]].push(obj);
                } else {
                    questions[elements[1]]= [obj];
                }
            }, {})
let result = [];
for (let prop in questions) {
    result.push({ "quizAns": questions[prop], "quizQuestion": prop });
}
console.log(result);