Four Fundamental Operations（JS） --结对项目

一、Github地址：https://github.com/BayardM/Four-Fundamental-Operations

（本项目由鲍鱼铭3118004995 和 许铭楷3118005023共同结对完成）

二、效能分析

　　性能提升和效率提升主要体现在下图

　　

　　在实现了1个运算符两个操作数的结果计算之后，原本是打算同样的思路进行2个，3个运算符的计算，但是做到一大半时感觉实在非常麻烦，开发效率及其低下！

　　便想到自己可以通过对操作数进行有限的变换来达到对更低层次的1个运算符函数的调用，换成这种嵌套调用之后减少了做运算的操作，也减少了底层对临时栈的调用，既提升了运行效率

　　也提升了开发效率！

三、设计实现过程（思路）

　　　　1-9需求均已实现

　　　　此处以流程图展示关键的实现各种算式结果生成的具体思路

　　　　

（前两个流程图最后忘记加得出结果一栏。。）

至于随机生成算式则是分为随机操作数和随机操作符两部分，操作数调用随机数库函数，操作符通过随机数字0123对应+-*/随机生成。

四、关键部分代码

　　1.二元算式结果计算函数

 function two_oper(op1, op2 , sel_oper1)
 {
     var result
     var formula = [op1 , sel_oper1 , op2]
     switch(sel_oper1)
     {
         case 0:
             result = op1 + op2
             break
         case 1:
             var high_op = op1>op2 ? op1 : op2
             var low_op = op1<op2 ? op1 : op2
             result = high_op - low_op
             break
         case 2:
             result = op1 * op2
             break
         case 3:
             if(op1%op2 != 0)
             {
                 if(op1/op2 >= 1)
                 result = parseInt(op1/op2) + "'" + op1%op2 + '/' + op2
                 else result = op1 + '/' + op2
             }else{
                 result = op1 / op2
             }
             break
         default:break
     }
     for (var j=0; j<3; j++) {
         Formula[j] = formula[j]
     }
     return result
 }

　　2.三元算式结果计算

 function thr_oper(op1 , op2 , op3 , sel_oper1 , sel_oper2)
 {
     var formula = [op1 , sel_oper1 , op2 , sel_oper2 , op3]
     var result
     switch(sel_oper1)
     {
         case 0:
             switch(sel_oper2)
             {
                 case 0:
                      result = formula[0] + formula[2] + formula[4]
                     break
                 case 1:
                     var high_op = (formula[0]+formula[2])>formula[4] ? (formula[0]+formula[2]) : formula[4]
                     var low_op = (formula[0]+formula[2])<formula[4] ? (formula[0]+formula[2]) : formula[4]
                     result = two_oper(high_op , low_op , sel_oper2)
                     if(high_op == formula[4])
                     {
                         formula[0] = op3
                         formula[4] = op1
                         formula[1] = sel_oper2
                     }
                     break
                 case 2:
                     result = formula[0] + (formula[2] * formula[4])
                     break
                 case 3:
                     result = two_oper((formula[0]*formula[4]+formula[2]) , formula[4] , sel_oper2)
                     break
                 default:break
             }
             break
         case 1:
             switch(sel_oper2)
             {
                 case 0:
                     var high_op = (formula[0]+formula[4])>formula[2] ? (formula[0]+formula[4]) : formula[2]
                     var low_op = (formula[0]+formula[4])<formula[2] ? (formula[0]+formula[4]) : formula[2]
                     result = two_oper(high_op , low_op , sel_oper1)
                     if(high_op == formula[2])
                     {
                         formula[0] = op2
                         formula[2] = op1
                         formula[3] = sel_oper1
                     }
                     break
                 case 1:
                     var high_op = (formula[2]+formula[4])>formula[0] ? (formula[2]+formula[4]) : formula[0]
                     var low_op = (formula[2]+formula[4])<formula[0] ? (formula[2]+formula[4]) : formula[0]
                     result = two_oper(high_op , low_op , sel_oper2)
                     if(high_op == (formula[2]+formula[4]))
                     {
                         formula[0] = op3
                         formula[4] = op1
                         formula[1] = sel_oper2-1
                     }
                     break
                 case 2:
                     var high_op = (formula[2]*formula[4])>formula[0] ? formula[2]*formula[4] : formula[0]
                     var low_op = (formula[2]*formula[4])<formula[0] ? formula[2]*formula[4] : formula[0]
                     result = two_oper(high_op , low_op , sel_oper1)
                     if(high_op == (formula[2]*formula[4]))
                     {
                         formula[0] = op3
                         formula[4] = op1
                         formula[1] = 2
                         formula[3] = 1
                     }
                     break
                 case 3:
                     var high_op = (formula[0]*formula[4])>formula[2] ? formula[0]*formula[4] : formula[2]
                     var low_op = (formula[0]*formula[4])<formula[2] ? formula[0]*formula[4] : formula[2]
                     //
                     result = two_oper((high_op-low_op) ,formula[4] , sel_oper2)
                     if(formula[2]> (formula[0]*formula[4]))
                     {
                         formula[0] = op2
                         formula[2] = op3
                         formula[4] = op1
                         formula[1] = sel_oper2
                         formula[3] = sel_oper1
                     }
                     break
                 default:break
             }
             break
         case 2:
             switch(sel_oper2)
             {
                 case 0:
                      result = formula[0] * formula[2] + formula[4]
                     break
                 case 1:
                     result = two_oper((formula[0]*formula[2]) , formula[4] , sel_oper2)
                     if(formula[4]> (formula[0]*formula[2]))
                     {
                         formula[0] = op3
                         formula[4] = op1
                         formula[1] = sel_oper2
                         formula[3] = sel_oper1
                     }
                     break
                 case 2:
                     result = formula[0] * formula[2] * formula[4]
                     break
                 case 3:
                     result = two_oper((formula[0]*formula[2]) , formula[4] , sel_oper2)
                     break
                 default:break
             }
             break
         case 3:
             switch(sel_oper2)
             {
                 case 0:
                     result = two_oper((formula[0]+formula[4]*formula[2]) , formula[2] , sel_oper1)
                     break
                 case 1:
                     var high_op = formula[0]>(formula[2]*formula[4]) ? formula[0] : (formula[2]*formula[4])
                     var low_op = formula[0]<(formula[2]*formula[4]) ? formula[0] : (formula[2]*formula[4])
                     result = two_oper((high_op-low_op) ,formula[2] , sel_oper1)
                     if((formula[2]*formula[4]) > formula[0])
                     {
                         formula[0] = op3
                         formula[2] = op1
                         formula[4] = op2
                         formula[1] = sel_oper2
                         formula[3] = sel_oper1
                     }
                     break
                 case 2:
                     result = two_oper((formula[0]*formula[4]) , formula[2] , sel_oper1)
                     break
                 case 3:
                     result = two_oper(formula[0] , (formula[2]*formula[4]) , sel_oper1)
                     break
                 default:break
             }
             break
         default: break
 }
     for (var j=0; j<5; j++) {
             Formula[j] = formula[j]
         }
     return result
 }

　　3.四元结果算式代码过长，暂不做展示

　　4.ffo函数----算式生成函数

 function ffo(max){
 var op_gath = Math.floor(Math.random()*(3)+2)
 var sel_oper1 = Math.floor(Math.random()*4)
 var sel_oper2 = Math.floor(Math.random()*4)
 var sel_oper3 = Math.floor(Math.random()*4)
 var result
 switch(op_gath)
 {
     case 2:
         var op1 = Math.floor(Math.random()*(max)+1)
         var op2 = Math.floor(Math.random()*(max)+1)
         result = two_oper(op1 , op2 , sel_oper1)
         if((sel_oper1 == 1)&&(op1 < op2))
         {
             Formula[0] = op2
             Formula[2] = op1
         }
         canswer[cindex] = result
         cindex++
         myanswer[index] = '答案' + (index+1)+': '+result
         index++
         Formula[0] = String(Formula[0])
         Formula[2] = String(Formula[2])
         Formula[1] = operator[Formula[1]]
         for(var i=0; i<3; i++)
         document.write(Formula[i])
         document.write('=' + '<input type="text" />' + '<br />')
         break
     case 3:
         var op1 = Math.floor(Math.random()*(max)+1)
         var op2 = Math.floor(Math.random()*(max)+1)
         var op3 = Math.floor(Math.random()*(max)+1)
         result = thr_oper(op1 , op2 , op3 , sel_oper1 , sel_oper2)
         canswer[cindex] = result
         cindex++
         myanswer[index] = '答案' + (index+1)+': '+result
         index++
         Formula[0] = String(Formula[0])
         Formula[2] = String(Formula[2])
         Formula[4] = String(Formula[4])
         Formula[1] = operator[Formula[1]]
         Formula[3] = operator[Formula[3]]
         for(var i=0; i<5; i++)
         document.write(Formula[i])
         document.write('=' + '<input type="text" />' + '<br />')
         break
     case 4:
         var op1 = Math.floor(Math.random()*(max)+1)
         var op2 = Math.floor(Math.random()*(max)+1)
         var op3 = Math.floor(Math.random()*(max)+1)
         var op4 = Math.floor(Math.random()*(max)+1)
         result = four_oper(op1 , op2 , op3 , op4 , sel_oper1 , sel_oper2 , sel_oper3)
         canswer[cindex] = result
         cindex++
         myanswer[index] = '答案' + (index+1)+': '+result
         index++
         Formula[0] = String(Formula[0])
         Formula[2] = String(Formula[2])
         Formula[4] = String(Formula[4])
         Formula[6] = String(Formula[6])
         Formula[1] = operator[Formula[1]]
         Formula[3] = operator[Formula[3]]
         Formula[5] = operator[Formula[5]]
         for(var i=0; i<7; i++)
         document.write(Formula[i])
         document.write('=' + '<input type="text" />' + '<br />')
         break
     default: break
 }
 }

　　5.检查对错功能函数

 function checkanswer(){
         var right = new Array()
         var wrong = new Array()
         var r_index=0
         var w_index=0
         var num=0
         var inputtag = document.getElementsByTagName('input')
         for (var j=0;j<inputtag.length;j++) {
             if(inputtag[j].value == "") continue
             else break
         }
         if(j==inputtag.length) alert("请输入答案再检查")
         else {
             for (var i=0 ; i<inputtag.length ;i++) {
             if(inputtag[i].value == canswer[i])
                 {
                     right[r_index] = i+1
                     r_index++
                 }
             else {
                 wrong[w_index] = i+1
                 w_index++
             }
         }
         var show = ['correct:' + (right.length) + '(' , 'wrong:' + (wrong.length) + '(' , ')']
         exportRaw('check.txt' , show[0]+right+show[2]+show[1]+wrong+show[2])
         }
 }

　　6.导出文件函数

 function fakeClick(obj) {
        　　var ev = document.createEvent("MouseEvents");
 　　　　ev.initMouseEvent("click", true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
 　　　　obj.dispatchEvent(ev);
 　　}

 　　function exportRaw(name, data) {
 　　　　var urlObject = window.URL || window.webkitURL || window;
         　var export_blob = new Blob([data]);
 　　　　var save_link = document.createElementNS("http://www.w3.org/1999/xhtml", "a")
 　　　　save_link.href = urlObject.createObjectURL(export_blob);
         save_link.download = name;
 　　　　fakeClick(save_link);
 　　}

　五、测试运行

　　1.定义题目数量

　　

　　2.定义范围

　　

　　3.10道题目生成，范围为10以内，答案txt

　　4.输入答案检查对错功能

　　

　　5.10000道题目生成

　　

六、PSP表格

PSP2.1	Personal Software Process Stages	预估耗时（分钟）	实际耗时（分钟）
Planning	计划	50	50
· Estimate	· 估计这个任务需要多少时间	20	20
Development	开发	180	220
· Analysis	· 需求分析 (包括学习新技术)	125	140
· Design Spec	· 生成设计文档	40	30
· Design Review	· 设计复审 (和同事审核设计文档)	10	10
· Coding Standard	· 代码规范 (为目前的开发制定合适的规范)	5	5
· Design	· 具体设计	120	100
· Coding	· 具体编码	120	160
· Code Review	· 代码复审	60	180
· Test	· 测试（自我测试，修改代码，提交修改）	120	350
Reporting	报告	60	60
· Test Report	· 测试报告	60	70
· Size Measurement	· 计算工作量	10	10
· Postmortem & Process Improvement Plan	· 事后总结, 并提出过程改进计划	20	45
合计		1000	1445

七、个人项目总结

许铭楷：

　　　　这次作业用js完成，因为我js掌握还不是很深，大部分功能都是同伴完成的，我主要负责代码的检测和改错。在合作的过程中同伴尽心尽力帮助我解决了很多问题，我也学习到了很多的新知识。总的来说，这次训练带给了我很多进步，让我充分感受到合作的重要性。

鲍鱼铭：

　　　　本次合作我承担的部分是具体编码和功能实现的部分，本以为自己做的不错可以减轻同伴负担，但是没想到交给同伴进行测试和debug的过程中竟然漏洞百出，幸好同伴细心检查，不断测试发现问题。问题主要呈现在减法不能存在负数与除法的真分数实现，在同伴的帮忙下自己很快得到改进。本次合作除了项目开发上的收获以外，更重要的是收获了与人合作的经历，深刻地明白了自己一个人做事总是会考虑不周全，也充分锻炼了以后到了真正工作时期与人沟通交流和接受意见的能力，收获颇丰！