mock-examer.js

"use strict";
// 题库
let questions;
// 当前正在执行的题目随机选取顺序
let shuffle_index;
// 当前所在题目索引，分为随机模式和顺序模式
let current_index = {random: 0, sequential: 0};
// 当前做题模式
let current_mode;
// 当前题目选取方式（随机/顺序）
let order = "random";
// 单选题是否必选
let radio_required = true;

// 用于答案的时候：处理答案是小写字母的情况
//
// 用于选项的时候：根据选项的索引生成选项的大写字母序号
function to_capital_letter(c) {
    if (c >= "1" && c <= "9")
        return "-ABCDEFGHI"[parseInt(c)];
    if (c >= "a" && c <= "z")
        return c.toUpperCase();
    return c;
}

function import_questions() {
    questions = JSON.parse(document.getElementById("questions").value);
    for (let question of questions)
        question[1] = to_capital_letter(question[1]);
    shuffle_index = Array.from({length: questions.length}, (_, i) => i);
    shuffle(shuffle_index);
    current_index.random = current_index.sequential = 0;
    settings.count.max = questions.length;
    document.getElementById("import").innerHTML = `导入成功，共导入题目${questions.length}道`;
    setTimeout(_ => document.getElementById("import").innerHTML = "导入题库", 5000);
}

function shuffle(array) {
    for (let i = array.length - 1; i > 0; i--) {
        let j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
}

function generate_question_content(question, index) {
    let content = "";
    const multi = question[1].length > 1;
    content += `<div id="${index}" class="question ${multi ? "multi" : "single"}" data-answer="${question[1]}">${question[0]}<span class="hide-answer">【答案：${question[1]}】</span></div>`;
    content += '<div>';
    for (let opt = 0; opt < question[2].length; opt++)
        content += `<div class="option"><label><input type="${multi ? "checkbox" : "radio"}" name="opt_for_${index}" value="${to_capital_letter(opt + 1)}" ${multi ? "" : (radio_required ? "required" : "")}>${question[2][opt]}</label></div>`;
    content += '</div>';
    return content;
}

function get_next_question() {
    const question = questions[order === "random" ? shuffle_index[current_index.random] : current_index.sequential];
    current_index[order]++;
    settings.question_order[0].parentElement.title = current_index.random + "/" + shuffle_index.length;
    settings.question_order[1].parentElement.title = current_index.sequential + "/" + shuffle_index.length;
    if (current_index[order] === shuffle_index.length) {
        current_index[order] = 0;
        if (order === "random" && current_mode === "endless")
            shuffle(shuffle_index);
    }
    return question;
}

function random_questions(count) {
    let selected_questions = [];
    for (let i = 0; i < count; i++)
        selected_questions.push(get_next_question());
    let content = "";
    for (let i = 0; i < count; i++)
        content += generate_question_content(selected_questions[i], i);
    document.getElementById("exam-content").innerHTML = content;
    document.getElementById("exam-content").dataset.count = count;
    document.getElementById("submit").disabled = false;
}

function endless_next_question() {
    const question = get_next_question();
    const new_question_index = document.getElementById("exam-content").dataset.count;
    let content = generate_question_content(question, new_question_index);
    document.getElementById("exam-content").insertAdjacentHTML("beforeend", content);
    document.getElementById("exam-content").dataset.count++;
    localStorage.endless_status = document.getElementById("exam-content").innerHTML;
}

function check_answer() {
    if (current_mode !== "endless")
        document.getElementById("submit").disabled = true;
    let i;
    if (current_mode === "endless")
        i = document.getElementById("exam-content").dataset.count - 1;
    else
        i = 0;
    for (; i < document.getElementById("exam-content").dataset.count; i++) {
        const question_element = document.getElementById("exam-content").children[i * 2];
        const answer = question_element.dataset.answer;
        // question_element.innerHTML += `【答案：${answer}】`;
        const options_element = exam["opt_for_" + question_element.id];
        const user_answer = Array.from(options_element).filter(v => v.checked).map(v => v.value).join("");
        if (user_answer === answer)
            question_element.className += " correct";
        else
            question_element.className += " incorrect";
        for (let j = 0; j < options_element.length; j++) {
            options_element[j].disabled = true;
            if (options_element[j].checked && !answer.includes(options_element[j].value))
                options_element[j].parentElement.parentElement.className = "option incorrect";
            if (answer.includes(options_element[j].value))
                options_element[j].parentElement.parentElement.className = "option correct";
            // 给用户已选的选项加上checked属性，以便在历史记录中还原用户的选择
            if (options_element[j].checked)
                options_element[j].setAttribute("checked", "");
        }
    }
    // 在每一局无尽模式中，每次提交只保留最后一次提交的历史记录
    // 删除之前要确保将被删除的历史记录是当前答题区内容的前缀，否则可能会导致误删
    // 例如先在无尽模式答题，然后再切换到别的模式答题，然后又切换到无尽模式继续刚才的进度，如果不作判断的话，就有可能会误删刚才在别的模式的答题记录
    if (current_mode === "endless" && parseInt(document.getElementById("exam-content").dataset.count) > 1)
        if (Object.keys(history).length !== 0)
            if (document.getElementById("exam-content").innerHTML.startsWith(history[Object.keys(history).at(-1)]))
                delete history[Object.keys(history).at(-1)];
    history[Date.now()] = document.getElementById("exam-content").innerHTML;
    update_history_selector();
    localStorage.history = JSON.stringify(history);
    if (current_mode !== "free")
        document.getElementById("exam-result").innerHTML
            = `正确率：${document.querySelectorAll(".question.correct").length}/${document.getElementById("exam-content").dataset.count}`;
    if (current_mode === "endless")
        endless_next_question();
}

function update_option_elements() {
    settings.count.disabled = settings.mode.value !== "classic";
    settings.history_id.disabled = settings.mode.value !== "error_practice";
    if (settings.mode.value === "error_practice")
        update_history_selector();
}

function toggle_radio_required() {
    radio_required = settings.radio_required.value === "yes";
    let radios = exam.querySelectorAll('input[type="radio"]');
    if (radio_required) {
        for (let radio of radios)
            radio.setAttribute("required", "");
    } else {
        for (let radio of radios)
            radio.removeAttribute("required");
    }
}

function toggle_question_order() {
    order = settings.question_order.value;
}

function start() {
    const new_mode = settings.mode.value;
    switch (new_mode) {
        case "free":
            random_questions(1);
            break;
        case "classic":
            random_questions(settings.count.valueAsNumber);
            break;
        case "endless":
            let continue_endless_progress;
            if (localStorage.endless_status)
                continue_endless_progress = confirm("发现有进行中的无尽模式答题记录，是否继续上次的进度？\n确定：继续上次的进度\n取消：开始一局新的无尽模式");
            if (localStorage.endless_status && continue_endless_progress) {
                document.getElementById("exam-content").innerHTML = localStorage.endless_status;
                document.getElementById("exam-content").dataset.count = document.querySelectorAll(".question").length.toString();
                document.getElementById("exam-result").innerHTML
                    = `正确率：${document.querySelectorAll(".question.correct").length}/${parseInt(document.getElementById("exam-content").dataset.count) - 1}`;
                toggle_radio_required();
            } else {
                random_questions(1);
            }
            break;
        case "error_practice":
            const history_id = settings.history_id.value;
            if (history_id in history) {
                if (!history[history_id].includes(" incorrect")) {
                    alert("此答题记录中没有错题");
                    return;
                }
                document.getElementById("exam-content").innerHTML = history[history_id];
                // 删除做对了的题目，只留下做错的题目
                for (let element of exam.querySelectorAll(".question.correct, .question.correct + div"))
                    element.remove();
                // 删除各种做完题目产生的标记，使题目重新可作答
                let question_elements = exam.querySelectorAll(".question");
                for (let element of question_elements)
                    element.className = element.className.replace(" incorrect", "");
                document.getElementById("exam-content").dataset.count = question_elements.length.toString();
                for (let element of exam.querySelectorAll(".option"))
                    element.className = "option";
                for (let element of exam.querySelectorAll('input[type="radio"], input[type="checkbox"]')) {
                    element.removeAttribute("checked");
                    element.removeAttribute("disabled");
                }
            } else {
                alert("此答题记录不存在");
                return;
            }
            break;
    }
    document.getElementById("exam-content").className = current_mode = new_mode;
    document.getElementById("exam-result").innerHTML = "";
    document.getElementById("submit").disabled = false;
}

function endless_restart() {
    if (confirm("确定要重新开始无尽模式吗？\n当前进度将丢失")) {
        random_questions(1);
        document.getElementById("exam-result").innerHTML = "";
    }
}