confirmit中自创相应函数

// 报错语句再次整合。 以下很多函数调用了这里的简化版err()报错函数。
function err(para){
  RaiseError();
  ClearErrorMessage();
  SetQuestionErrorMessage(CurrentLang(), para);
}

// loop_id ： loop题 的id
// 作用：loop下的题计数，出示第几个了。 返回 第几个的值
function count(loop_id){
    var codes_arr=f(loop_id).domainValues();
    for(var i=0; i<codes_arr.length; i++){
        if(f(loop_id).value()==codes_arr[i]){
            return i+1;
        }
    }
}

// loopQus：loop题id
// QUS：loop题下的出示的题id
// code： QUS选中的单个code
// 作用：获取LOOP题 选中code的集合品牌
// 在此QUS:单选题，code: 单个code值。
// 如果QUS: 多选题，code参数要去掉，函数里的code参数换成类似 '1','3','4'
function getLoop(loopQus, QUS, code) {
    var loopcode = f(loopQus).domainValues();
    var oset = new Set();
    for (var i = 0; i < loopcode.length; i++) {
        if (f(QUS, loopcode[i]).any(code)) {
            oset.add(loopcode[i]);
        }
    }
    return oset;
}

// string: 传入的字符串。
// 作用：正则表达式去空格，返回清除空格后的字符串
function strim_ldx(string){
    return string.replace(/\s/g,'');
}

// QID: grid题号， error_statement: 报错语句
// 如果 grid左侧和上方的选项个数都大于 1  ， 则可以去掉left 和 top变量的相关代码
function checkGridLine(QID,error_statement) {
    if( !QuestionErrors() ){ 
        // grid左侧选项code
        var left=f(QID).domainValues();
        // grid上方选项code
        var top=f(QID)[left[0]].domainValues();

        if (lset(f(QID).values()).size() == 1 && left.length>1 && top.length>1) {
            RaiseError();
            ClearErrorMessage();
            SetQuestionErrorMessage(CurrentLang(), error_statement);
        }
    }
}

/* 
check 是一个辅助单选题,作用是充当提醒变量使用，初始设置check自动圈选code==1,  
当某题 达到提醒条件时，并且判断check是否选中1，如果是则输出报错（提醒）语句，并且check选中2. 
如果用户不改，那么不再输出报错（提醒）语句，同时check 回到初始状态选中code==1。
*/
// 软的直线报错：报错一次可以过
function checkGridLineSoft(QID,error_statement) {
    if( !QuestionErrors() ){ 
        if (lset(f(QID).values()).size() == 1 && f('check').any('1')) {
            f('check').set('2');
            err(error_statement);
        }else{
            f('check').set('1');
        }
    }
}
// QID,error_statement,n
// grid题id,  报错语句， 数量
// Grid 题型：连续选择n个及以上相同的答案报错
function checkGridLine2(QID,error_statement,n) {
    if( !QuestionErrors() ){ 
        var val = f(QID).values();
        for (var i = 0; i < val.length - n + 1; ++i) {
            if (lset(val.slice(i, i + n)).size() == 1 ) {
                err(error_statement)
                break;
            }
        }
    }
}

// Grid 题型：连续选择n个及以上相同的答案/ 报错一次
function checkGridLineSoft2(QID, error_statement, n) {
    if (!QuestionErrors()) {
        var val = f(QID).values();
        for (var i = 0; i < val.length - n + 1; ++i) {
            if (lset(val.slice(i, i + n)).size() == 1 && f('check').any('1')) {
                f('check').set('2');
                err(error_statement)
                break;
            } else {
                f('check').set('1')
            }
        }
    }
}

// arr: multi grid左侧的codes组成的数组； QID: multi grid题号； error_statement: 报错语句
function checkMultiGridLine(arr,QID,error_statement){
    var leftCodes=arr;
    var r=new Set();
    for(var i=0; i<leftCodes.length; i++){
        r.add(f(QID+'_'+leftCodes[i]).values());
    }
    /* 如果确定multi 左边和上方出示的code的数量 > 1 ,则下方if 条件中只用 r.size()==1 判断即可 */
    if(r.size()==1 && leftCodes.length>1 && f(QID+'_'+leftCodes[0]).domainValues().length>1){
        err(error_statement)
    }
}

// arr: multi grid左侧的codes组成的数组； QID: multi grid题号； error_statement: 报错语句
// 软报错：报错一次
function checkMultiGridLineSoft(arr,QID,error_statement){
    var leftCodes=arr;
    var r=new Set();
    for(var i=0; i<leftCodes.length; i++){
        r.add(f(QID+'_'+leftCodes[i]).values());
    }
    if(r.size()==1 && f('check').any('1')){
        f('check').set('2');
        err(error_statement);
    }else {
        f('check').set('1');
    }
}

// arr: multi grid左侧的codes组成的数组； QID: multi grid题号； error_statement: 报错语句, n: n个连续的答案一致
// Multi Grid 题型：连续选择n个及以上相同的答案报错
function checkMultiGridLine2(arr,QID,error_statement,n) {
    if( !QuestionErrors() ){ 
        var leftCodes=arr;
        for (var i = 0; i < leftCodes.length - n+1; ++i) {
            var r=new Set();
            for (var m = i; m < i + n; ++m) {
                r.add(f(QID+'_' + leftCodes[m]).values());
            }
            if (r.size() == 1) {
                err(error_statement)
            }
        }
    }
}

// Multi Grid 题型：连续选择n个及以上相同的答案/ 报错一次
function checkMultiGridLineSoft2(arr,QID, error_statement, n) {
    if (!QuestionErrors()) {
        var leftCodes=arr;
        var count=0;
        for (var i = 0; i < leftCodes.length - n+1; ++i) {
            var r=new Set();
            for (var m = i; m < i + n; ++m) {
                r.add(f(QID+'_' + leftCodes[m]).values());
            }
            if(r.size()==1){
                count++;
            }
        }
        if (count>0 && f('check').any('1')) {
            f('check').set('2');
            err(error_statement);
        }else {
            f('check').set('1')
        }
    }
}

// 家庭月总收入 选项 >= 个人月收入
// A: 个人收入题id ; B: 家庭收入题id
function AtoB(A,B) {
    var allCodes = a(B).members(),
        needCodes = new Set();
    for (var i = 0; i < allCodes.length; ++i) {
        if (allCodes[i] >= f(A).toNumber()) {
            needCodes.add(allCodes[i]);
        }
    }
    return needCodes;
}

/* QSOPEN: 单独填空题； QSSAMPLE:多个名称的多选题； QSSING: 单独填空题内容符合某个名称被赋值的单选题 */
function singleOpenToEndByBrand(QSOPEN,QSSAMPLE,QSSING){
    var content=f(QSOPEN).get();
    var SampleCodes=f(QSSAMPLE).domainValues();

    for(var i=0;i<SampleCodes.length;i++){
        var code=SampleCodes[i];
        var codeLabel=f(QSSAMPLE)[code].label();
        /* 这里的分隔符为 中文 的 逗号 */
        var LabelArr=codeLabel.split('，');
        for(var j=0;j<LabelArr.length;j++){
            if(strim(content).toLowerCase()==strim(LabelArr[j].toLowerCase())){
                // 单独填空题内容符合某个名称被赋值的 单 选题使用以下代码
                f(QSSING).set(code);
                // 单独填空题内容符合某个名称被赋值的 多 选题使用以下代码
                // f(QSSING)[code].set('1');
            }
        }
    }
}

/* QSOPEN: 多填空题； QSSAMPLE:多个名称的多选题； QMMULTI: 多填空题内容符合某个名称被赋值的多选题 */
function multiOpenToEndByBrand(QSOPEN,QSSAMPLE,QMMULTI){
    var openCodes=f(QSOPEN).categories();
    for(var k=0; k<openCodes.length; k++){
        var content=f(QSOPEN)[openCodes[k]].get();
        var SampleCodes=f(QSSAMPLE).domainValues();

        for(var i=0;i<SampleCodes.length;i++){
            var code=SampleCodes[i];
            var codeLabel=f(QSSAMPLE)[code].label();
            /* 这里的分隔符为 中文 的 逗号 */
            var LabelArr=codeLabel.split('，');
            for(var j=0;j<LabelArr.length;j++){
                if(strim(content).toLowerCase()==strim(LabelArr[j].toLowerCase())){
                    f(QMMULTI)[code].set('1');
                }
            }
        }
    }
}

// 清楚字符串空格函数
function strim(string) { 
  var tempstr; 
  tempstr = string.replace(/(^\s+)|(\s+$)/g, ""); // delete spaces 
  tempstr = tempstr.replace(/(^　+)|(　+$)/g, ""); // delete 2-byte spaces 
  return tempstr; 
}

// 单开放题检查是否为空值/空格
function sOpenCheckNull(QID){
    //if( !QuestionErrors() ){  ,另外strim是一个自创去空格的函数
    if( f(QID).toBoolean() ){
        if (strim(f(QID).get()) == '') {
            RaiseError();
            ClearErrorMessage();
            SetQuestionErrorMessage(CurrentLang(), "请不要输入空值，谢谢！");
        }
    }
}

// 单开放题 检查是否 包含汉字或字母（拼音）
// 如果输入的para包含汉字或字母  就返回 true,否则返回false
function haveEandC(para)  {
    var re=/[a-zA-Z | \u4e00-\u9fa5]/; //包含汉字或字母（拼音）
    return re.test(para);
}
// 多开放题检查是否 包含汉字或字母（拼音），附带报错语句
function eAndC(qId){
    if(!QuestionErrors()){
        var codes=f(qId).categories();
        for(var i=0; i<codes.length; i++){
            if(!haveEandC(f(qId)[codes[i]].get())){ 
                err('请填写汉字或拼音！') ;
                break;
            }
        }
    }
}

/* 是否按顺序填写： 通过连续的两个作比较，判断是否前一个没填内容&&后一个填了内容 */
function openSort(QID) {
    var codes = f(QID).domainValues();
    for (var i = 0; i < codes.length - 1; i++) {
        if (!f(QID)[codes[i]].toBoolean() && f(QID)[codes[i + 1]].toBoolean()) {
            RaiseError();
            ClearErrorMessage();
            SetQuestionErrorMessage(CurrentLang(), "请按顺序填写，谢谢");
            break;
        }
    }
}