货货检检中中级级判判断断题题
试卷总分：95
答题时间：[ 未设置 ]
1.  货检作业人员应按照规         着装，佩带臂章。 (    )[333010101][1分]正确答案 (对)
对     错
2.  货运检查员允许兼职，与其他工种混岗。 (    )[333010101][1分]正确答案 (错)
对     错
3.  货运检查人员应熟练掌握规章中有关技术要求和人身安全规                     。 (    )[321010101][1分]正确答案 (对)
对     错
4.  货运检查站应配齐有关规章，并指             货运检查值班员负责规章的保管，及时组织对规、修规。 (    )
[312010101][1分]正确答案 (错)
对     错
5.  无守列车交接检查中，发现货车已施封，但编组顺序表无 “F”字样，须编制记录证明现状继运。 (    )
[311010102][1分]正确答案 (对)
对     错
6.  无守列车交接检查中，列车编组顺序表上对施封的货车未记明 “F”字样，货车一侧无封，发生被盗丢失事故后，
由责任单位与该列车的编组站共同负责，事故列责任单位。 (    )[311010102][1分]正确答案 (对)
对     错
7.  货运检查站应建立健全货运检查工作岗位责任制及管理办法。 (    )[321010201][1分]正确答案 (错)
对     错
8.  货运检查作业时，应采取有效的防护措施，确保货运检查人员的人身和作业安全。 (    )[321010201]
[1分]正确答案 (对)
对     错
9.  超限货物车辆无挂运命令可编入小运转列车。 (    )[211020201][1分]正确答案 (错)
对     错
10. 货运检查站应建立货运检查工具及备品登记簿。 (    )[321010202][1分]正确答案 (对)
对     错
11. 路网性货运检查站应逐步配齐轨道衡、超偏载检测装置等有关行车安全检测设备。 (    )[321010202]
[1分]正确答案 (错)
对     错
12. 路网性货运检查站是指铁路局公布的编组站。 (    )[321020101][1分]正确答案 (错)
对     错
13. 区域性货运检查站由铁路局自  ，报铁道部备案、公布。 (    )[312020101][1分]正确答案 (对)
对     错
14. 铁路局间交接货运检查站的撤销应报铁道部批准、公布。 (    )[321020101][1分]正确答案 (对)
对     错
15. 在货运交接检查中对货车票据完整情况不进行交接检查。 (    )[311020102][1分]正确答案 (错)
对     错
16. 敞车在电气化区段接触网未停电的线路上可以手推调车。 (    )[211010101][1分]正确答案 (错)
对     错
17. 无守列车交接检查中，发现货物装载有异状或超过货车装载限界，由发现站按规                           换装或整理并拍发电报。 (
)[311020102][1分]正确答案 (对)
对     错
18. 冷藏车车体夹层装有隔热材料，车体外部涂以黄色，对阳光起反射作用，减少太阳辐射热传人车内。 (    )
[221030101][1分]正确答案 (错)
对     错
19. 禁止溜放表示牌的 “禁止溜放”栏印红地白字，其余各栏印白地蓝格字。 (    )[311020102]
[1分]正确答案 (错)
对     错
20. 遇有特殊情况必须临时对营业站加以限制时，属铁路局管内的须经铁道部批准。 (    )[321020102]
[1分]正确答案 (错)
对     错
21. 车站受理货物运单时，应确认领货凭证与运单相关栏一致。 (    )[321020102][1分]正确答案 (对)
对     错
22. 安装禽畜支架属于装卸车附属作业。 (    )[321020102][1分]正确答案 (对)

f=open(r'E:\我的文件\判断题.txt')
fnew=open(r'E:\我的文件\判断题-json.txt','a')
sum=0
str0=''
f1=f.readlines()
print(f1)
for f0 in f1:
    sum=sum+1
print(sum)
for i in range(0,sum):
        th=str(int(i+1))+'、'
        print(th)
        if(f1[i].find("（ √ ）")!=-1):
            str0='{"name":"'+f1[i].replace("（ √ ）","")+'","daan":"√"},'
        elif(f1[i].find("（ x ）")!=-1):
            str0='{"name":"' + f1[i].replace("（ x ）", "") + '","daan":"x",'
        else:
            print("发生错误")
        str0 = str0.replace('\n', '').replace(th, '') + '\n'
        print(str0)
        fnew.write(str0)
fnew.close()
f.close()
转前的.txt文件：

转后的json格式文件：

判断题


  
1．验收测试是由最终用户来实施的。（╳） 
  
  

    
解析：当软件以项目的形式出现，那么验收测试由最终用户来实施的情况是比较长见的。但是对于产品形式的软件，生产企业内部的验收测试会更多。
  
  
  
2．软件测试的目的是尽可能多的找出软件的缺陷。（√）
  
  
3．Beta测试是验收测试的一种。（√）
  
  
4．项目立项前测试人员不需要提交任何工件。（√）
  
  
5．自底向上集成需要测试员编写驱动程序。（√）
  
  
6．自底向下集成需要测试员编写桩模块（√）
  
  
7．负载测试是验证要检验的系统的能力最高能达到什么程度（╳）
  
  

    
解析：负载测试:是一种性能测试，指数据在超负荷环境中运行，程序是否能够承担。 

    压力测试:是在一定的负荷条件下，长时间连续运行系统给系统性能造成的影响。
  
  
  
8．测试人员要坚持原则，缺陷未修复完坚决不予通过（╳）
  
  
9．集成测试计划在需求分析阶段末提交（╳）
  
  

    
解析：集成测试计划在开发人员完成软件集成计划之后就可以开始进行了。所以在需求分析阶段之后提交是不现实的事情，应该在软件的设计阶段后，编码前。
  
  
  
10．我们可以人为的使得软件不存在配置问题（╳） 
  
  
11．软件测试按照测试过程分类为黑盒、白盒测试（╳） 
  
  
12．在设计测试用例时，应包括合理的输入条件和不合理的输入条件。（╳）
  
  
14．单元测试属于动态测试（╳）
  
  
15．缺陷跟踪系统只针对对测试人员来使用（╳）
  
  
16．从用户软件开发者的角度出发，普遍希望通过软件测试暴露软件中隐藏的错误和缺陷，以考虑是否可接受该产品（╳）
  
  
17．软件项目在进入需求分析阶段，测试人员应该开始介入其中（√）
  
  
18．软件生存周期是从软件开始开发到开发结束的整个时期（╳）
  
  
19．单元测试能发现约80%的软件缺陷（√）
  
  
20．数据流图和数据字典共同构成系统的逻辑模型（√）
  
  
21．测试组负责软件质量（╳）
  
  
22．程序的效率与程序的复杂性相关（╳）
  
  
23．详细设计的目的是为软件结构图中的的每一个模块确定使用的算法和块内数据结构，并用某种选定的表达工具给出清晰的描述（√）
  
  
24．软件是一种逻辑实体，而不是具体的物理实体，因而它具有抽象性（√）
  
  
25．测试程序仅仅按预期方式运行就行了（╳）
  
  
26．软件测试就是为了验证软件功能实现的是否正确，是否完成既定目标的活动，所以软件测试在软件工程的后期才开始具体的工作（ × ）
  
  
27．发现错误多的模块，残留在模块中的错误也多( √ ) 
  
  
28．测试人员在测试过程中发现一处问题，如果问题影响不大，而自己又可以修改，应立即将此问题正确修改，以加快、提高开发的进程（ × ）
  
  
29．单元测试通常应该先进行“人工走查”，再以白盒法为主，辅以黑盒法进行动态测试（ √ ）
  
  
30．功能测试是系统测试的主要内容，检查系统的功能、性能是否与需求规格说明相同（ √ ）
  
  
31．软件质量管理即QM由QA和QC构成，软件测试属于QC的核心工作内容（√）
  
  
32．软件测试只能发现错误，但不能保证测试后的软件没有错误（√）
  
  
33．软件就是程序（X）
  
  
34．测试只要做到语句覆盖和分支覆盖，就可以发现程序中的所有错误（X）
  
  
35．I18N测试是指对产品做出具有国际性的规划，而L10N测试则是指对软件做出符合本地需求更改工作（√）
  
  
37． 广义的软件测试由“确认“、”验证“、”测试“3个方面组成（√）
  
  
38．测试人员说：”没有可运行的程序，我无法进行测试工作“（X）
  
  
39．白盒测试方法比黑盒测试方法好（X）
  
  
40．V模型不能适应较大的需求变化（√）
  
  
41．W模型能够较早地发现缺陷（√）
  
  
42．测试需求就是软件需求（X）
  
  
43．测试需求一定要写的很细很细（X）
  
  
44．一个程序中所含有的路径数与程序的复杂程度有着直接的关系（√）
  
  
45．静态检查就是看代码（X）
  
  
46．等价类法和边界值法着重考虑输入条件，而不考虑输入条件的各种组合，也不考虑输入条件之间的相互制约关系（√）
  
  
47．因果图法师建立在决策表法基础上的一种白盒测试方法（X）
  
  
48．黑盒测试又叫功能测试或数据驱动测试（√）
  
  
49．测试用例一般是由测试设计人员写的（√）
  
  
50．  测试用例是在测试执行后写的（X）
  
  
51． 在设计测试用例时，应包括合理的输入条件和不合理的输入条件（√）  
  
  
52．采用自动化测试有可能延误项目进度（√）    
  
  
53． 面向对象的软件测试时采用面向对象的概念和原则，用结构化的方法构建（X）
  
  
54．WAS是单元测试工具（X）
  
  
55．Web网站测试需要考虑数据库测试（√）
  
  
56． 敏捷测试不需要写测试计划（X）
  
  
57．Junit是一个开源的Java单元测试框架（√）            

vue+element 实现 试卷答题功能，单选题  ,多选题，判断题，简答题（2.0版本，2021.3.25更新）
文章目录
vue+element 实现 试卷答题功能，单选题  ,多选题，判断题，简答题（2.0版本，2021.3.25更新）
难点：
一、后端返回数据（）
方法一
页面
1.html
2.js - 答题部分
3.js - 回显部分
方法二：
1.html
2.js - 答题部分
3.js - 回显部分
总结
方法一优点：可以使用表单的任何属性，使用方便
方法一缺点：有报错，看着难受
方法二优点：没有报错，不用搞那么多乱七八糟的函数，看着省心，用着及其方便
方法二缺点：无法使用表单的任何属性，自己动手丰衣足食



难点：

如何循环不同类型的题
如何记录点击的是哪道题，并且分清楚他是单选还是多选
单选还好，多选的话不能出现点了一道题，其他题的答案都是点击的这个选项
回显的时候如何再把值赋上去
附加功能：设置开始时间和结束时间，未到时间不可答题（后端做判断），到时间后自动提交


要和后端商量，把所有时间搞成秒，这样好判断时间到没到，分钟的话太大，毫秒的话，不可能那么精确，而且脸黑的话，两个毫秒值永远不可能相等
ps： 一定要看注释
一、后端返回数据（）

{
    "returnObject": {
        "count": 380,
        "list": [
            {
                "createTime": 1597030865000,
                "delFlag": "0",
                "id": 285,
                "num": 0,
                "questionType": "1",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "JEIIXJIEJXIJIEXIJEIX",
                "stAnswer": "B",
                "stContent": "多数轿车更换发动机机油的周期里程为________km。",
                "stScore": 10,
                "stSelecta": "2000--3000",
                "stSelectb": "5000--8000",
                "stSelectc": "10000--12000",
                "stSelectd": "14000--16000",
                "stType": "1"
            },
            {
                "createTime": 1597030865000,
                "delFlag": "0",
                "id": 286,
                "num": 0,
                "questionType": "1",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "JEIIXJIEJXIJIEXIJEIX",
                "stAnswer": "B",
                "stContent": "关于镶套修理法，下面说法不正确的是（  ）",
                "stScore": 10,
                "stSelecta": "镶套后改变了零件的尺寸",
                "stSelectb": "镶套材料应尽量与基体一致",
                "stSelectc": "镶套采用了过盈配合",
                "stSelectd": "配合表面要求加工精度较高",
                "stType": "1"
            },
            {
                "createTime": 1608101282000,
                "delFlag": "0",
                "id": 452,
                "num": 0,
                "questionType": "3",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "无",
                "stAnswer": "A,B,C",
                "stContent": "对磁盘与驱动器中，叙述正确的有",
                "stCteater": "1",
                "stScore": 10,
                "stSelecta": "密度",
                "stSelectb": "扇区",
                "stSelectc": "磁道",
                "stSelectd": "光标本",
                "stSelecte": "孔口",
                "stSelectf": "",
                "stType": "1"
            },
            {
                "createTime": 1608099445000,
                "delFlag": "0",
                "id": 443,
                "num": 0,
                "questionType": "3",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "无",
                "stAnswer": "A,C,B",
                "stContent": "计算机的主要特点是",
                "stCteater": "1",
                "stScore": 10,
                "stSelecta": "运算速度快",
                "stSelectb": "精度高",
                "stSelectc": "存储记忆",
                "stSelectd": "自动编程",
                "stSelecte": "用十进制计数",
                "stSelectf": "",
                "stType": "1"
            },
            {
                "createTime": 1606957884000,
                "delFlag": "0",
                "id": 372,
                "num": 0,
                "questionType": "2",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "JEIIXJIEJXIJIEXIJEIX",
                "stAnswer": "错",
                "stContent": "int是引用数据类型",
                "stScore": 10,
                "stSelecta": "对",
                "stSelectb": "错",
                "stType": "1"
            },
            {
                "createTime": 1606957884000,
                "delFlag": "0",
                "id": 373,
                "num": 0,
                "questionType": "2",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "JEIIXJIEJXIJIEXIJEIX",
                "stAnswer": "错",
                "stContent": "string是引用数据类型",
                "stScore": 10,
                "stSelecta": "对",
                "stSelectb": "错",
                "stType": "1"
            },
            {
                "createTime": 1606957884000,
                "delFlag": "0",
                "id": 376,
                "num": 0,
                "questionType": "4",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "JEIIXJIEJXIJIEXIJEIX",
                "stAnswer": "数组和链表的区别",
                "stContent": "ArrayList和LinkedList的区别",
                "stScore": 10,
                "stType": "1"
            },
            {
                "createTime": 1545893669000,
                "delFlag": "0",
                "id": 44,
                "num": 0,
                "questionType": "4",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "JEIIXJIEJXIJIEXIJEIX",
                "stAnswer": "数组和链表的区别",
                "stContent": "1ArrayList和LinkedList的区别",
                "stScore": 10,
                "stSelecta": "",
                "stSelectb": "",
                "stSelectc": "",
                "stSelectd": "",
                "stType": "3"
            }
        ]
    },
    "code": "200",
    "message": "成功"
}

方法一
页面
1.html
	<!-- 页面标题 -->
    <div class="VSTD_box" v-if="question.length !== 0">
      <h1 style="margin-bottom: 40px; text-align: center">
        {{ iow.sjIntroduction }}
      </h1>
		<!-- 题的表单 -->
		<!-- 绑定表单的数据 ruleForm -->
		<!-- 绑定题的数组 ruleForm.resource[index] -->

		data{
			return{
		      ruleForm: {
		        resource: [],
		      },
			}
		}

      <el-form
        :model="ruleForm"
        :rules="rules"
        ref="ruleForm"
        label-width="100px"
        class="demo-ruleForm"
      >
          <!-- 循环后端给你的所有题 -->
        <div
          class="VSTD_box_item"
          v-for="(item, index) in question"
          :key="item.id"
        >

          <!-- 1 单选 -->
          <!-- 2 判断 -->
          <!-- 3 多选 -->
          <!-- 4 简答 -->

          <div class="VSTD_box_item_title">
          
          <!-- 题目的信息 -->
          
            <p style="font-weight: 700">
              第{{ index + 1 }}题：{{ item.stContent
              }}<span>（{{ item.stScore }}分）</span>
              <span v-if="item.questionType == 1">（单选）</span>
              <span v-if="item.questionType == 2">（判断）</span>
              <span v-if="item.questionType == 3">（多选）</span>
              <span v-if="item.questionType == 4">（简答）</span>
            </p>
          </div>

          <!-- 如果questionType 等于1 那么他是单选题 -->
          <!-- 题目绑定的值是 ruleForm.resource[index]  -->
          
          <div v-if="item.questionType == 1" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <el-radio-group v-model="ruleForm.resource[index]">
                <el-radio label="A">{{ item.stSelecta }}</el-radio>
                <el-radio label="B">{{ item.stSelectb }}</el-radio>
                <el-radio label="C">{{ item.stSelectc }}</el-radio>
                <el-radio label="D">{{ item.stSelectd }}</el-radio>
              </el-radio-group>
            </el-form-item>
          </div>
          
          <!-- 如果questionType 等于2 那么他是判断题 -->
          <!-- 题目绑定的值是 ruleForm.resource[index]  -->
          
          <div v-if="item.questionType == 2" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <el-radio-group v-model="ruleForm.resource[index]">
                <el-radio label="对">{{ item.stSelecta }}</el-radio>
                <el-radio label="错">{{ item.stSelectb }}</el-radio>
              </el-radio-group>
            </el-form-item>
          </div>
          
          <!-- 如果questionType 等于3 那么他是多选题 -->
          <!-- 题目绑定的值是 ruleForm.resource[index]  -->
          
          <div v-if="item.questionType == 3" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <el-checkbox-group
                @input="change($event)"
                v-model="ruleForm.resource[index]"
              >
                <el-checkbox label="A">{{ item.stSelecta }}</el-checkbox>
                <el-checkbox label="B">{{ item.stSelectb }}</el-checkbox>
                <el-checkbox label="C">{{ item.stSelectc }}</el-checkbox>
                <el-checkbox label="D">{{ item.stSelectd }}</el-checkbox>
                <el-checkbox label="E">{{ item.stSelecte }}</el-checkbox>
                <!-- <el-checkbox label="F">{{ item.stSelectf }}</el-checkbox> -->
              </el-checkbox-group>
            </el-form-item>
          </div>

          <!-- 如果questionType 等于4 那么他是简答题 -->
          <!-- 题目绑定的值是 ruleForm.resource[index]  -->
          
          <div v-if="item.questionType == 4" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <!-- <el-form-item label="活动形式"> -->
              <el-input
                type="textarea"
                v-model="ruleForm.resource[index]"
              ></el-input>
            </el-form-item>
          </div>
        </div>
        
          <!-- 提交函数  -->
          
        <el-form-item style="text-align: center">
          <el-button type="primary" @click="submitForm('ruleForm', false)"
            >提交</el-button
          >
        </el-form-item>
      </el-form>
    </div>
    
          <!-- 如果没题就提示没题 -->
          
    <div v-else>
      <div class="none" style="margin-left: 0px">
        <div class="none_img"></div>
        <h3>暂无试题</h3>
      </div>
    </div>

          <!-- 表单提交后显示分数的弹窗 -->
          
    <el-dialog
      title="您此次评分为"
      :visible.sync="dialogVisible"
      width="30%"
      @close="handleClose"
    >
      <span style="font-size: 60px; color: #3e80f8">{{ score }}分</span>
      <span slot="footer" class="dialog-footer">
        <el-button @click="back()">返回</el-button>
        <el-button type="primary" @click="go">我的测评</el-button>
      </span>
    </el-dialog>

2.js - 答题部分

//数据定义

  data() {
    return {
      score: 0,						//表单提交后，后端返回的总分
      id: '',						//获取路由的 query，试卷的id
      iow: '',						//返回的题目信息
      dialogVisible: false,			//弹窗
      djStarttime: '',				//获取当前时间
      question: [],					//保存后端返回题的数组，页面上需要用它来循环显示每一道题
      ruleForm: {
        resource: [],				//每一道题的值
      },

      DSQ: null,					//定时器，到时间自动提交
      DSQTime: 0,					//后端返回的结束时间	
      questionArrText: [],			//答题保存的数组
    }
  },

逻辑

  created() {
    var djStarttime = new Date()
    var year = djStarttime.getFullYear()
    var month = (djStarttime.getMonth() + 1).toString()
    var day = djStarttime.getDate().toString()
    var hour = djStarttime.getHours().toString()
    var minute = djStarttime.getMinutes().toString()
    var second = djStarttime.getSeconds().toString()
    if (month.length == 1) {
      month = '0' + month
    }
    if (day.length == 1) {
      day = '0' + day
    }
    if (hour.length == 1) {
      hour = '0' + hour
    }
    if (minute.length == 1) {
      minute = '0' + minute
    }
    if (second.length == 1) {
      second = '0' + second
    }
    this.djStarttime =
      year + '-' + month + '-' + day + ' ' + hour + ':' + minute + ':' + second

    this.id = this.$route.query.id

	//获取当前系统时间，传给后端，用来判断他用了多长时间

    //console.log(this.dateTime)
    this.init()		//初始化函数
  },

	//监听定时器，如果 当前系统时间的秒值等于或大于后端给定的时间，那么就自动提交题目

  watch: {
    DSQTime: function (val, oldVal) {
      console.log(this.DSQTime)
      console.log(this.DSQEndTime)
      if (this.DSQTime == this.DSQEndTime) {
        clearInterval(this.DSQ)
        this.submitForm('ruleForm', true)
      }
    },
  },


  methods: {
	//给多选框用，否则会出现一个bug，就是先点一下多选框，然后没反应，
	//然后点一下按钮或者点击下拉框后，这个多选框就高亮了
    change(e) {
      this.$forceUpdate()
    },
    
    //关闭弹窗函数
    handleClose(done) {
      this.dialogVisible = false
    },
    
    //跳页面的函数
    
    go() {
      this.$router.push({ path: '/ME' })
    },
    
    //返回上一页
    
    back() {
      this.$router.go(-1)
    },

	//初始化函数

    init() {
	//定时器，获取当前系统时间（毫秒），然后转化为秒
      this.DSQ = setInterval(() => {
        this.DSQTime = parseInt(Date.now() / 1000)
      }, 1000)
      
      //封装的接口，把试卷id传进去，返回所有题
      
      msgApi
        .questionsList(this.id)
        .then((res) => {
          if (res.data.code == 200) {
            this.question = res.data.returnObject.list			//页面循环的题
            for (let i = 0; i < this.question.length; i++) {
            
            	//如果他是多选题的话，把它初始化为一个数组，而不是普通的字符串
            	
              if (this.question[i].questionType == 3) {
                this.ruleForm.resource[i] = []
              }else{
				this.ruleForm.resource[i] = ''
			  }
            }
            this.questionArrText = res.data.returnObject.list	//重新赋值，用来判断他是否全部答完
            this.iow = res.data.returnObject.name				//题的名字
            this.DSQEndTime = parseInt(this.iow.endTime / 1000)	//后端返回的时间（毫秒）转化为秒
          }
        })
        .catch((err) => {})
    },
	
	//提交函数
	//ifs 判断是否是用户自己点击的提交按钮，如果不是，那么就是到时间了，系统自动提交的
	
    submitForm(formName, ifs) {
      if (ifs) {

		//系统自动提交的话
		
        var arr = []											//最后给后端的是一个json串
        var that = this
        var b = this.ruleForm.resource.notempty()
        //获取他已经答过的题
        for (var i = 0; i < this.questionArrText.length; i++) {
          var json = {}											//最后给后端的是一个json串
          json.id = that.questionArrText[i].id					//json的id：题id
          
          
          //如果是数组（也就是多选题），那么就用join把他换为字符串
          if (that.ruleForm.resource[i] instanceof Array) {
            json.text = that.ruleForm.resource[i].join()
          } else {
            json.text = that.ruleForm.resource[i]
          }
          
          if (json.text == undefined) {						//如果这个题没答，那么久把他重置为空串，而不是给后端一个 undefined 字符串
            json.text = ''
          }
          json.isJD = this.questionArrText[i].questionType	//给后端题的类型

          arr.push(json)									//一个一个push进去
        }
        var obj = {											//传的采纳数
          djPaperid: this.id,
          djStarttime: this.djStarttime,
          djAnswers: JSON.stringify(arr),
        }
        msgApi
          .answers(obj)										//请求的接口
          .then((res) => {
            if (res.data.code == 200) {
              //console.log(res)
              this.dialogVisible = true
              this.score = res.data.returnObject
            }
          })
          .catch((err) => {})
      } else {
        this.$refs[formName].validate((valid) => {			//如果是用户自己点的
          if (valid) {
            var arr = []
            var that = this
            var b = this.ruleForm.resource.notempty()
            if (b.length !== this.questionArrText.length) {	

				//要是有未答的题目走if

              this.$confirm(
                '检测到您有未答完的题目，，是否确认提交试卷？',
                '确认信息',
                {
                  distinguishCancelAndClose: true,
                  confirmButtonText: '确认',
                  cancelButtonText: '取消',
                }
              )
                .then(() => {			
                		
                //逻辑和刚刚的一样，
                
                  for (var i = 0; i < this.questionArrText.length; i++) {
                    var json = {}
                    json.id = that.questionArrText[i].id
                    if (that.ruleForm.resource[i] instanceof Array) {
                      json.text = that.ruleForm.resource[i].join()
                    } else {
                      json.text = that.ruleForm.resource[i]
                    }
                    if (json.text == undefined) {
                      json.text = ''
                    }
                    json.isJD = this.questionArrText[i].questionType

                    arr.push(json)
                  }

                  var obj = {
                    djPaperid: this.id,
                    djStarttime: this.djStarttime,
                    djAnswers: JSON.stringify(arr),
                  }
                  msgApi
                    .answers(obj)
                    .then((res) => {
                      if (res.data.code == 200) {
                        //console.log(res)
                        this.dialogVisible = true
                        this.score = res.data.returnObject
                      }
                    })
                    .catch((err) => {})
                })
                .catch((action) => {})
            } else {													

				//如果都答了，就走else  （其实这个感觉没必要，不过就这吧）

              for (var i = 0; i < this.questionArrText.length; i++) {
                var json = {}
                json.id = that.questionArrText[i].id
                if (that.ruleForm.resource[i] instanceof Array) {
                  json.text = that.ruleForm.resource[i].join()
                } else {
                  json.text = that.ruleForm.resource[i]
                }

                json.isJD = this.questionArrText[i].questionType

                arr.push(json)
              }

              var obj = {
                djPaperid: this.id,
                djStarttime: this.djStarttime,
                djAnswers: JSON.stringify(arr),
              }
              msgApi
                .answers(obj)
                .then((res) => {
                  if (res.data.code == 200) {
                    //console.log(res)
                    this.dialogVisible = true
                    this.score = res.data.returnObject
                    // this.$message.success(res.data.returnObject)
                  }
                })
                .catch((err) => {})
            }
          } else {
            //console.log('error submit!!')
            return false
          }
        })
      }
    },
    resetForm(formName) {
      this.$refs[formName].resetFields()
    },
  },





3.js - 回显部分
题目方面和之前的html一样，就是多了个disabled属性，
然后让后端把你给后端的json串拿到手之后，你再去获取到，做一个回显

就发题目部分吧，其他的没什么用

        <div
          class="VSTD_box_item"
          v-for="(item, index) in question"
          :key="item.id"
        >
          <div class="VSTD_box_item_title">
            <p>
              第{{ index + 1 }}题：{{ item.stContent
              }}<span>（{{ item.stScore }}分）</span>
            </p>
          </div>
          <div v-if="item.questionType == 1" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource" style="margin-bottom: 0px">

			<!-- 注意，这里回显的时候要 加上一个类型  -->
			<!-- 单选，简答，判断用这个 ruleForm.resource[index].text   -->
			<!-- 多选用这个 ruleForm.resource[index].textarray-->
 
			<!-- 因为数据类型不一样，所以要区分  -->

              <el-radio-group v-model="ruleForm.resource[index].text">
                <el-radio disabled label="A">{{ item.stSelecta }}</el-radio>
                <el-radio disabled label="B">{{ item.stSelectb }}</el-radio>
                <el-radio disabled label="C">{{ item.stSelectc }}</el-radio>
                <el-radio disabled label="D">{{ item.stSelectd }}</el-radio>
              </el-radio-group>
            </el-form-item>
            <span style="margin-left: 100px">
              <div class="msgss">
                <div>
                  正确答案：<span class="right">{{ item.stAnswer }}</span>
                </div>
                <div>
                  考生答案：<span class="error">
                    {{ ruleForm.resource[index].text }}</span
                  >
                </div>
              </div>
            </span>
          </div>
          <div v-if="item.questionType == 2" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource" style="margin-bottom: 0px">
              <el-radio-group v-model="ruleForm.resource[index].text">
                <el-radio disabled label="对">{{ item.stSelecta }}</el-radio>
                <el-radio disabled label="错">{{ item.stSelectb }}</el-radio>
              </el-radio-group>
            </el-form-item>
            <span style="margin-left: 100px">
              <div class="msgss">
                <div>
                  正确答案：<span class="right">{{ item.stAnswer }}</span>
                </div>
                <div>
                  考生答案：<span class="error">
                    {{ ruleForm.resource[index].text }}</span
                  >
                </div>
              </div>
            </span>
          </div>
          <div v-if="item.questionType == 3" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <el-checkbox-group
                @input="change($event)"
                v-model="ruleForm.resource[index].textarray"
                style="margin-bottom: 0px"
              >
                <el-checkbox disabled label="A">{{
                  item.stSelecta
                }}</el-checkbox>
                <el-checkbox disabled label="B">{{
                  item.stSelectb
                }}</el-checkbox>
                <el-checkbox disabled label="C">{{
                  item.stSelectc
                }}</el-checkbox>
                <el-checkbox disabled label="D">{{
                  item.stSelectd
                }}</el-checkbox>
                <el-checkbox disabled label="E">{{
                  item.stSelecte
                }}</el-checkbox>
              </el-checkbox-group>
            </el-form-item>
            <span style="margin-left: 100px">
              <div class="msgss">
                <div>
                  正确答案：<span class="right">{{ item.stAnswer }}</span>
                </div>
                <div>
                  考生答案：<span class="error">
                    {{ ruleForm.resource[index].text }}</span
                  >
                </div>
              </div>
            </span>
          </div>
          <div v-if="item.questionType == 4" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource" style="margin-bottom: 0px">
              <el-input
                disabled
                type="textarea"
                v-model="ruleForm.resource[index].text"
              ></el-input>
            </el-form-item>
            <span style="margin-left: 100px">
              <div class="msgss">
                <div>
                  正确答案：<span class="right">{{ item.stAnswer }}</span>
                </div>
                <div>
                  考生答案：<span class="error">
                    {{ ruleForm.resource[index].text }}</span
                  >
                </div>
              </div>
            </span>
          </div>
        </div>


  data() {						//data还是这个
    return {
      score: 0,
      id: '',
      dialogVisible: false,
      djStarttime: '',
      question: [],
      ruleForm: {
        resource: [],
      },
      iow: '',
      allanswer: [],
      questionArr: [],
      rules: {
        resource: [
          // { required: true, message: '请输入活动名称', trigger: 'blur' }
        ],
      },
    }
  },

	//init 函数有点不一样，先请求题目接口，然后请求答案接口
    init() {

		//题目接口

      msgApi
        .questionsList_look(this.id)
        .then((res) => {
          if (res.data.code == 200) {
            this.question = res.data.returnObject.list
            for (let i = 0; i < this.question.length; i++) {
              this.questionArr.push(this.question[i].id)
            }
            this.iow = res.data.returnObject.name
          }
        })
        .catch((err) => {})
      msgApi
        .MyAnswer(this.id)
        .then((res) => {
          if (res.data.code == 200) {
            //console.log(res.data.returnObject)
            this.allanswer = res.data.returnObject
            this.answer = res.data.returnObject.contArray
            console.log(this.answer)
            this.ruleForm.resource = this.answer
          }
        })
        .catch((err) => {})
    },



方法二：
ps ：就是在后端返回题的时候，直接在返回的数据中创建一个保存答案的键值对，然后页面在v-model的时候，把这个创建的值再加上去就行了（但是这种方法和表单没有任何关系，也就是说不能使用表单验证等一系列的功能，只能用$message提示用户）
1.html
	<!-- 页面标题 -->
    <div class="VSTD_box" v-if="question.length !== 0">
      <h1 style="margin-bottom: 40px; text-align: center">
        {{ iow.sjIntroduction }}
      </h1>
      <el-form
        ref="ruleForm"
        label-width="100px"
        class="demo-ruleForm"
      >
          <!-- 循环后端给你的所有题 -->
        <div
          class="VSTD_box_item"
          v-for="(item, index) in question"
          :key="item.id"
        >

          <!-- 1 单选 -->
          <!-- 2 判断 -->
          <!-- 3 多选 -->
          <!-- 4 简答 -->

          <div class="VSTD_box_item_title">
          
          <!-- 题目的信息 -->
          
            <p style="font-weight: 700">
              第{{ index + 1 }}题：{{ item.stContent
              }}<span>（{{ item.stScore }}分）</span>
              <span v-if="item.questionType == 1">（单选）</span>
              <span v-if="item.questionType == 2">（判断）</span>
              <span v-if="item.questionType == 3">（多选）</span>
              <span v-if="item.questionType == 4">（简答）</span>
            </p>
          </div>

          <!-- 如果questionType 等于1 那么他是单选题 -->
          <!-- 题目绑定的值是 每一项的 item.resource  -->
          
          <div v-if="item.questionType == 1" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <el-radio-group v-model="item.resource">
                <el-radio label="A">{{ item.stSelecta }}</el-radio>
                <el-radio label="B">{{ item.stSelectb }}</el-radio>
                <el-radio label="C">{{ item.stSelectc }}</el-radio>
                <el-radio label="D">{{ item.stSelectd }}</el-radio>
              </el-radio-group>
            </el-form-item>
          </div>
          
          <!-- 如果questionType 等于2 那么他是判断题 -->
          <!-- 题目绑定的值是 每一项的 item.resource  -->
          
          <div v-if="item.questionType == 2" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <el-radio-group v-model="item.resource">
                <el-radio label="对">{{ item.stSelecta }}</el-radio>
                <el-radio label="错">{{ item.stSelectb }}</el-radio>
              </el-radio-group>
            </el-form-item>
          </div>
          
          <!-- 如果questionType 等于3 那么他是多选题 -->
          <!-- 题目绑定的值是  每一项的 item.resource  -->
          
          <div v-if="item.questionType == 3" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <el-checkbox-group
                @input="change($event)"
                v-model="item.resource"
              >
                <el-checkbox label="A">{{ item.stSelecta }}</el-checkbox>
                <el-checkbox label="B">{{ item.stSelectb }}</el-checkbox>
                <el-checkbox label="C">{{ item.stSelectc }}</el-checkbox>
                <el-checkbox label="D">{{ item.stSelectd }}</el-checkbox>
                <el-checkbox label="E">{{ item.stSelecte }}</el-checkbox>
                <!-- <el-checkbox label="F">{{ item.stSelectf }}</el-checkbox> -->
              </el-checkbox-group>
            </el-form-item>
          </div>

          <!-- 如果questionType 等于4 那么他是简答题 -->
          <!-- 题目绑定的值是  每一项的 item.resource  -->
          
          <div v-if="item.questionType == 4" class="VSTD_box_item_select">
            <el-form-item label="" prop="resource">
              <!-- <el-form-item label="活动形式"> -->
              <el-input
                type="textarea"
                v-model="item.resource"
              ></el-input>
            </el-form-item>
          </div>
        </div>
        
          <!-- 提交函数  -->
          
        <el-form-item style="text-align: center">
          <el-button type="primary" @click="submitForm()"
            >提交</el-button
          >
        </el-form-item>
      </el-form>
    </div>
    
          <!-- 如果没题就提示没题 -->
          
    <div v-else>
      <div class="none" style="margin-left: 0px">
        <div class="none_img"></div>
        <h3>暂无试题</h3>
      </div>
    </div>


2.js - 答题部分

//数据定义

  data() {
    return {
      question: [],					//保存后端返回题的数组，页面上需要用它来循环显示每一道题
    }
  },

逻辑

  created() {
    this.init()		//初始化函数
  },


  methods: {
	//给多选框用，否则会出现一个bug，就是先点一下多选框，然后没反应，
	//然后点一下按钮或者点击下拉框后，这个多选框就高亮了

	//初始化函数

    init() {
      
      msgApi
        .questionsList(this.id)
        .then((res) => {
          if (res.data.code == 200) {
          var json = res.data.returnObject.list
            for (let i = 0; i < json.length; i++) {
            
            	//如果他是多选题的话，把它初始化为一个数组，而不是普通的字符串
            	
              if (json[i].questionType == 3) {
                json[i].resource = []		
                //直接给每一项加一个resource属性，因为res.data他是一个对象，所以可以任意给他添加新的键值对
              }else{
              	json[i].resource = ''
			  }
            }
          }
            this.question = json			//页面循环的题
        })
        .catch((err) => {})
    },
	

3.js - 回显部分
后端也是会给你返回这样的数据
{
    "returnObject": {
        "count": 380,
        "list": [
            {
                "createTime": 1597030865000,
                "delFlag": "0",
                "id": 285,
                "num": 0,
                "questionType": "1",
                "sjIntroduction": "计算机基本知识",
                "stAnalysis": "JEIIXJIEJXIJIEXIJEIX",
                "stAnswer": "B",
                "stContent": "多数轿车更换发动机机油的周期里程为________km。",
                "stScore": 10,
                "stSelecta": "2000--3000",
                "stSelectb": "5000--8000",
                "stSelectc": "10000--12000",
                "stSelectd": "14000--16000",
                "stType": "1"
                "用户选择的答案": "A"		//会给你个这个字段
            }
        ]
    },
    "code": "200",
    "message": "成功"
}

就是多了一个字段，然后你再把这个字段赋值给item.resource 即可
总结
其他不难，难的是如何使用v-model绑定数据，然后如何让他点哪个哪个高亮

还有个问题，就是点一下选项，控制台会报一大堆数据类型错误，虽然不影响使用，但是还是很难受，好像就是 resource: [] 因为他是个数组，不是对象，但是可以使用表单验证等自带的东西
方法一优点：可以使用表单的任何属性，使用方便
方法一缺点：有报错，看着难受
方法二优点：没有报错，不用搞那么多乱七八糟的函数，看着省心，用着及其方便
方法二缺点：无法使用表单的任何属性，自己动手丰衣足食