在HBuilderX的javaScript中,如保尝试将字符转化为数字, 比如: 将字符"55e2a"

分类：HBuilderX

function StrToIntDef(myStr, iIntDef) {  
  var retInt;  
  try {  
    retInt = parseInt(myStr);  
    if (isNaN(retInt)) {  
      retInt = iIntDef;  
    }  
  } catch (e) {  
    //TODO handle the exception  
    retInt = iIntDef;  
  };  
  return retInt;  
};

我搞了上面这样一个函数,但是, 如果传入的是"数字开头的字符",比如:'55e2a'
它会转化成55, 我希望它转化不成功.

哪位仁兄知道如何处理吗?

(当然,我还知道一种方法,就是每一位检查过去,看它是否在0--9之间, 当然,还要考虑科学计数法问题)

2023-02-07 20:59 负责人:无分享

4 个回复

1***@qq.com (作者)

我自已花了2个多小时, 写了一个手工转化的函数, 分享大家看一下,

欢迎大家指正其中的错误! ( 如有改进, 请告诉我一下)

后面有改进代码

1***@qq.com (作者)

再次改进一下:

function StrToIntDef(myStr, iIntDef) {  

  //"内置浏览器"中,执行的结果如下:  
  // 空==>(不是整数,取它的默认值)    
  // 88ABC==>(不是整数,取它的默认值)    
  // 0123456==>123456    
  // 123456==>123456    
  // E55==>(不是整数,取它的默认值)    
  // 65E==>(不是整数,取它的默认值)    
  // 33E4==>330000    
  // .44E5==>44000   
  // 2.5E==>(不是整数,取它的默认值)    
  // 55.E6==>55000000    
  // 22.3E2==>2230    
  // 22.31E2==>2231    
  // 22.31E+2==>2231    
  // 22.311E2==>(不是整数,取它的默认值)    
  // -22.3E2==>-2230    
  // -22.3E-2==>(不是整数,取它的默认值)    
  // -22.3E+2==>-2230      

  var rltBool = false;  
  var rltInt = -9999999999;  

  var i1 = 0;  
  var i2 = 0;  

  var iMinus = 1;  
  if (myStr.substr(0, 1) == '-') {  
    iMinus = -1;  
    myStr = myStr.substr(1);  
  }  

  if (myStr.substr(0, 1) == '.') {  
    //如果第1位就是小数点,我们补个零吧,宽容些吧,例如: ".44E5"我们改为"0.44E5"  
    myStr = '0'+myStr;  
  }    

  //统一转化为大字, 这样, 方便判断科技计数法中的"e"  
  myStr = myStr.toUpperCase().trim();  

  if (myStr.indexOf('E+') >= 0) {  
    //如果是科学计数法,含有: e+ ,则替换为e,  
    if ((myStr.replace('E+', 'E').length + 1) == myStr.length) {  
      //只出现一次e+ ====>替换后,长度刚好减1  
      //这是合格的  
      myStr = myStr.replace('E+', 'E');  
    } else {  
      //不合格的,有多个数字要  
      myStr = '';  
    }  
  };  

  //如果是: "55.E6"-->我们宽容些吧,帮它改为"55.0E6"  
  myStr=myStr.replace('.E','.0E');  

  if (myStr == '') {  
    //空客会串,直接返回false  
  } else {  
    var sIntSet = '0123456789';  
    var sErrorCharSet = '';  

    for (var i in myStr) {  
      if (sIntSet.indexOf(myStr[i]) < 0) {  
        sErrorCharSet = sErrorCharSet + myStr[i];  

      }  
    }  

    if (sErrorCharSet == '') {  
      //全部都是0--9之间的数字  
      rltBool = true;  
      rltInt = parseInt(myStr);  
      rltInt = iMinus * rltInt;  
    } else {  

      if (sErrorCharSet == 'E') {  

        //只有一个字母E,我们认为它是科学计数法,  
        //则E前面的位置必须是中间部分(不能是第1个或最后一个),  
        if ((myStr.indexOf('E') == 0) || (myStr.indexOf('E') == (myStr.length - 1))) {  
          //E在第1位,或者最后一位,则不是科学计数法  
          rltBool = false;  
        } else {  
          rltBool = true;  
          i1 = parseInt(myStr.substr(0, myStr.indexOf('E')));  
          i2 = Math.pow(10, parseInt(myStr.substr(myStr.indexOf('E') + 1)));  
          rltInt = i1 * i2;  
          rltInt = iMinus * rltInt;  
        }  
      } else if (sErrorCharSet == '.E') {  
        //前面是小数,后面是科学计数法  
        if ((myStr.indexOf('.') == 0) || (myStr.indexOf('E') == (myStr.length - 1))) {  
          //小数点在第1位,或者E在最后一位  
          rltBool = false;  
        } else if ((myStr.indexOf('E') - myStr.indexOf('.')) == 1) {  
          //小数点和E紧密相隔,中间无任何数字  
          rltBool = false;  
        } else {  
          //这里,还要判断小数点后面的位数和10的幂数  
          //比如: 1.2345E2 这个转为科学计数法,就是123.45它只是充其量算是小数,但不能算是整数  

          if ((myStr.indexOf('E') - myStr.indexOf('.') - 1) <= parseInt(myStr.substr(myStr.indexOf('E') + 1))) {  
            rltBool = true;  
            i1 = parseFloat(myStr.substr(0, myStr.indexOf('E')));  
            i2 = Math.pow(10, parseInt(myStr.substr(myStr.indexOf('E') + 1)));  
            rltInt = i1 * i2;  
            rltInt = iMinus * rltInt;  

          } else {  
            rltBool = false;  
          }  

        }  
      } else {  

        rltBool = false;  

      }  
    }  

  }  

  //最后,rltBool表示它是不是Int  
  //rltInt则表示它的最后值  
  if (rltBool == false) {  
    rltInt = iIntDef;  
  }  
  return rltInt;  
};

1***@qq.com (作者)

我又整理了一个转化为浮点的函数,


function StrToFloatDef(myStr, iFloatDef) {  

  //"内置浏览器"中,执行的结果如下:  
  // 09:35:38.122 空==>(非法Float, 取默认值)    
  // 09:35:38.126 88ABC==>(非法Float, 取默认值)    
  // 09:35:38.128 0123456==>123456    
  // 09:35:38.129 123456==>123456    
  // 09:35:38.133 12.3456==>12.3456    
  // 09:35:38.134 .3456==>0.3456    
  // 09:35:38.139 3456.==>3456    
  // 09:35:38.142 E55==>(非法Float, 取默认值)    
  // 09:35:38.143 65E==>(非法Float, 取默认值)    
  // 09:35:38.145 33E4==>330000    
  // 09:35:38.147 .44E5==>44000    
  // 09:35:38.150 2.5E==>(非法Float, 取默认值)    
  // 09:35:38.151 55.E6==>55000000    
  // 09:35:38.156 22.3E2==>2230    
  // 09:35:38.159 22.31E2==>2231    
  // 09:35:38.163 22.31E+2==>2231    
  // 09:35:38.167 22.311E2==>2231.1    
  // 09:35:38.171 -22.3E2==>-2230    
  // 09:35:38.176 -22.3E-2==>-0.223    
  // 09:35:38.179 -22.3E+2==>-2230    

  var rltBool = false;  
  var rltFloat = -9999999999;  

  var i1 = 0;  
  var i2 = 0;  

  var iMinus = 1;  
  if (myStr.substr(0, 1) == '-') {  
    iMinus = -1;  
    myStr = myStr.substr(1);  
  }  

  if (myStr.substr(0, 1) == '.') {  
    //如果第1位就是小数点,我们补个零吧,宽容些吧,例如: ".44E5"我们改为"0.44E5"  
    myStr = '0' + myStr;  
  }  

  //统一转化为大字, 这样, 方便判断科技计数法中的"e"  
  myStr = myStr.toUpperCase().trim();  

  var IsMinus_Power = 0  
  if (myStr.indexOf('E+') >= 0) {  
    //如果是科学计数法,含有: e+ ,则替换为e,  
    if ((myStr.replace('E+', 'E').length + 1) == myStr.length) {  
      //只出现一次e+ ====>替换后,长度刚好减1  
      //这是合格的  
      myStr = myStr.replace('E+', 'E');  
      IsMinus_Power = 1;  
    } else {  
      //不合格的,有多个数字要  
      myStr = '';  
    }  
  } else if (myStr.indexOf('') >= 0) {  
    //如果是科学计数法,含有: E- ,则替换为e,  
    if ((myStr.replace('', 'E').length + 1) == myStr.length) {  
      //只出现一次E- ====>替换后,长度刚好减1  
      //这是合格的  
      myStr = myStr.replace('', 'E');  
      IsMinus_Power = -1;  
    } else {  
      //不合格的,有多个数字要  
      myStr = '';  
    };  

  };  

  //如果是: "55.E6"-->我们宽容些吧,帮它改为"55.0E6"  
  myStr = myStr.replace('.E', '.0E');  

  if (myStr == '') {  
    //空客会串,直接返回false  
  } else {  
    var sIntSet = '0123456789';  
    var sErrorCharSet = '';  

    for (var i in myStr) {  
      if (sIntSet.indexOf(myStr[i]) < 0) {  
        sErrorCharSet = sErrorCharSet + myStr[i];  

      }  
    }  

    if ((sErrorCharSet == '') || (sErrorCharSet == '.')) {  
      //全部都是0--9之间的数字  
      rltBool = true;  
      rltFloat = parseFloat(myStr);  
      rltFloat = iMinus * rltFloat;  
    } else {  

      if (sErrorCharSet == 'E') {  

        //只有一个字母E,我们认为它是科学计数法,  
        //则E前面的位置必须是中间部分(不能是第1个或最后一个),  
        if ((myStr.indexOf('E') == 0) || (myStr.indexOf('E') == (myStr.length - 1))) {  
          //E在第1位,或者最后一位,则不是科学计数法  
          rltBool = false;  
        } else {  
          rltBool = true;  
          i1 = parseFloat(myStr.substr(0, myStr.indexOf('E')));  
          i2 = Math.pow(10, parseFloat(myStr.substr(myStr.indexOf('E') + 1)));  
          if (IsMinus_Power == -1) {  
            i2 = 1 / i2;  
          };  
          rltFloat = i1 * i2;  
          rltFloat = iMinus * rltFloat;  
        }  
      } else if (sErrorCharSet == '.E') {  
        //前面是小数,后面是科学计数法  
        if ((myStr.indexOf('.') == 0) || (myStr.indexOf('E') == (myStr.length - 1))) {  
          //小数点在第1位,或者E在最后一位  
          rltBool = false;  
        } else if ((myStr.indexOf('E') - myStr.indexOf('.')) == 1) {  
          //小数点和E紧密相隔,中间无任何数字  
          rltBool = false;  
        } else {  
          rltBool = true;  
          i1 = parseFloat(myStr.substr(0, myStr.indexOf('E')));  
          i2 = Math.pow(10, parseFloat(myStr.substr(myStr.indexOf('E') + 1)));  
          if (IsMinus_Power == -1) {  
            i2 = 1 / i2;  
          };  
          rltFloat = i1 * i2;  
          rltFloat = iMinus * rltFloat;  

        }  
      } else {  

        rltBool = false;  

      }  
    }  

  }  

  //最后,rltBool表示它是不是Int  
  //rltFloat则表示它的最后值  
  if (rltBool == false) {  
    rltFloat = iFloatDef;  
  }  
  return rltFloat;  
};

1***@qq.com (作者)

最后,统一改进为四个函数, 大家可以直接复制这个版的就行

StrToInt (可能返回值是isNaN)
StrToIntDef

StrToFloat (可能返回值是isNaN)
StrToFloatDef


function StrToInt(myStr) {  

  //"内置浏览器"中,执行的结果如下:  
  // 空==>(不是整数,取它的默认值)    
  // 88ABC==>(不是整数,取它的默认值)    
  // 0123456==>123456    
  // 123456==>123456    
  // 3456.==>3456    
  // E55==>(不是整数,取它的默认值)    
  // 65E==>(不是整数,取它的默认值)    
  // 33E4==>330000    
  // .44E5==>44000   
  // 2.5E==>(不是整数,取它的默认值)    
  // 55.E6==>55000000    
  // 22.3E2==>2230    
  // 22.31E2==>2231    
  // 22.31E+2==>2231    
  // 22.311E2==>(不是整数,取它的默认值)    
  // -22.3E2==>-2230    
  // -22.3E-2==>(不是整数,取它的默认值)    
  // -22.3E+2==>-2230      

  var rltBool = false;  
  var rltInt;  

  var i1 = 0;  
  var i2 = 0;  

  var iMinus = 1;  
  if (myStr.substr(0, 1) == '-') {  
    iMinus = -1;  
    myStr = myStr.substr(1);  
  }  

  if(myStr.substr(-1)=='.'){  
   //如果最后一个是小数点号,就直接删除它  
    myStr=myStr.substr(0,myStr.length-1);  
  };  

  if (myStr.substr(0, 1) == '.') {  
    //如果第1位就是小数点,我们补个零吧,宽容些吧,例如: ".44E5"我们改为"0.44E5"  
    myStr = '0' + myStr;  
  };  

  //统一转化为大字, 这样, 方便判断科技计数法中的"e"  
  myStr = myStr.toUpperCase().trim();  

  if (myStr.indexOf('E+') >= 0) {  
    //如果是科学计数法,含有: e+ ,则替换为e,  
    if ((myStr.replace('E+', 'E').length + 1) == myStr.length) {  
      //只出现一次e+ ====>替换后,长度刚好减1  
      //这是合格的  
      myStr = myStr.replace('E+', 'E');  
    } else {  
      //不合格的,有多个数字要  
      myStr = '';  
    }  
  };  

  //如果是: "55.E6"-->我们宽容些吧,帮它改为"55.0E6"  
  myStr = myStr.replace('.E', '.0E');  

  if (myStr == '') {  
    //空客会串,直接返回false  
  } else {  
    var sIntSet = '0123456789';  
    var sErrorCharSet = '';  

    for (var i in myStr) {  
      if (sIntSet.indexOf(myStr[i]) < 0) {  
        sErrorCharSet = sErrorCharSet + myStr[i];  

      }  
    }  

    if (sErrorCharSet == '') {  
      //全部都是0--9之间的数字  
      rltBool = true;  
      rltInt = parseInt(myStr);  
      rltInt = iMinus * rltInt;  
    } else {  

      if (sErrorCharSet == 'E') {  

        //只有一个字母E,我们认为它是科学计数法,  
        //则E前面的位置必须是中间部分(不能是第1个或最后一个),  
        if ((myStr.indexOf('E') == 0) || (myStr.indexOf('E') == (myStr.length - 1))) {  
          //E在第1位,或者最后一位,则不是科学计数法  
          rltBool = false;  
        } else {  
          rltBool = true;  
          i1 = parseInt(myStr.substr(0, myStr.indexOf('E')));  
          i2 = Math.pow(10, parseInt(myStr.substr(myStr.indexOf('E') + 1)));  
          rltInt = i1 * i2;  
          rltInt = iMinus * rltInt;  
        }  
      } else if (sErrorCharSet == '.E') {  
        //前面是小数,后面是科学计数法  
        if ((myStr.indexOf('.') == 0) || (myStr.indexOf('E') == (myStr.length - 1))) {  
          //小数点在第1位,或者E在最后一位  
          rltBool = false;  
        } else if ((myStr.indexOf('E') - myStr.indexOf('.')) == 1) {  
          //小数点和E紧密相隔,中间无任何数字  
          rltBool = false;  
        } else {  
          //这里,还要判断小数点后面的位数和10的幂数  
          //比如: 1.2345E2 这个转为科学计数法,就是123.45它只是充其量算是小数,但不能算是整数  

          if ((myStr.indexOf('E') - myStr.indexOf('.') - 1) <= parseInt(myStr.substr(myStr.indexOf('E') + 1))) {  
            rltBool = true;  
            i1 = parseFloat(myStr.substr(0, myStr.indexOf('E')));  
            i2 = Math.pow(10, parseInt(myStr.substr(myStr.indexOf('E') + 1)));  
            rltInt = i1 * i2;  
            rltInt = iMinus * rltInt;  

          } else {  
            rltBool = false;  
          }  

        }  
      } else {  

        rltBool = false;  

      }  
    }  

  }  

  return rltInt;  
};  

function StrToFloat(myStr) {  

  //"内置浏览器"中,执行的结果如下:  
  // 09:35:38.122 空==>(非法Float, 取默认值)    
  // 09:35:38.126 88ABC==>(非法Float, 取默认值)    
  // 09:35:38.128 0123456==>123456    
  // 09:35:38.129 123456==>123456    
  // 09:35:38.133 12.3456==>12.3456    
  // 09:35:38.134 .3456==>0.3456    
  // 09:35:38.139 3456.==>3456    
  // 09:35:38.142 E55==>(非法Float, 取默认值)    
  // 09:35:38.143 65E==>(非法Float, 取默认值)    
  // 09:35:38.145 33E4==>330000    
  // 09:35:38.147 .44E5==>44000    
  // 09:35:38.150 2.5E==>(非法Float, 取默认值)    
  // 09:35:38.151 55.E6==>55000000    
  // 09:35:38.156 22.3E2==>2230    
  // 09:35:38.159 22.31E2==>2231    
  // 09:35:38.163 22.31E+2==>2231    
  // 09:35:38.167 22.311E2==>2231.1    
  // 09:35:38.171 -22.3E2==>-2230    
  // 09:35:38.176 -22.3E-2==>-0.223    
  // 09:35:38.179 -22.3E+2==>-2230    

  var rltBool = false;  
  var rltFloat;  

  var i1 = 0;  
  var i2 = 0;  

  var iMinus = 1;  
  if (myStr.substr(0, 1) == '-') {  
    iMinus = -1;  
    myStr = myStr.substr(1);  
  }  

  if (myStr.substr(0, 1) == '.') {  
    //如果第1位就是小数点,我们补个零吧,宽容些吧,例如: ".44E5"我们改为"0.44E5"  
    myStr = '0' + myStr;  
  }  

  //统一转化为大字, 这样, 方便判断科技计数法中的"e"  
  myStr = myStr.toUpperCase().trim();  

  var IsMinus_Power = 0  
  if (myStr.indexOf('E+') >= 0) {  
    //如果是科学计数法,含有: e+ ,则替换为e,  
    if ((myStr.replace('E+', 'E').length + 1) == myStr.length) {  
      //只出现一次e+ ====>替换后,长度刚好减1  
      //这是合格的  
      myStr = myStr.replace('E+', 'E');  
      IsMinus_Power = 1;  
    } else {  
      //不合格的,有多个数字要  
      myStr = '';  
    }  
  } else if (myStr.indexOf('') >= 0) {  
    //如果是科学计数法,含有: E- ,则替换为e,  
    if ((myStr.replace('', 'E').length + 1) == myStr.length) {  
      //只出现一次E- ====>替换后,长度刚好减1  
      //这是合格的  
      myStr = myStr.replace('', 'E');  
      IsMinus_Power = -1;  
    } else {  
      //不合格的,有多个数字要  
      myStr = '';  
    };  

  };  

  //如果是: "55.E6"-->我们宽容些吧,帮它改为"55.0E6"  
  myStr = myStr.replace('.E', '.0E');  

  if (myStr == '') {  
    //空客会串,直接返回false  
  } else {  
    var sIntSet = '0123456789';  
    var sErrorCharSet = '';  

    for (var i in myStr) {  
      if (sIntSet.indexOf(myStr[i]) < 0) {  
        sErrorCharSet = sErrorCharSet + myStr[i];  

      }  
    }  

    if ((sErrorCharSet == '') || (sErrorCharSet == '.')) {  
      //全部都是0--9之间的数字  
      rltBool = true;  
      rltFloat = parseFloat(myStr);  
      rltFloat = iMinus * rltFloat;  
    } else {  

      if (sErrorCharSet == 'E') {  

        //只有一个字母E,我们认为它是科学计数法,  
        //则E前面的位置必须是中间部分(不能是第1个或最后一个),  
        if ((myStr.indexOf('E') == 0) || (myStr.indexOf('E') == (myStr.length - 1))) {  
          //E在第1位,或者最后一位,则不是科学计数法  
          rltBool = false;  
        } else {  
          rltBool = true;  
          i1 = parseFloat(myStr.substr(0, myStr.indexOf('E')));  
          i2 = Math.pow(10, parseFloat(myStr.substr(myStr.indexOf('E') + 1)));  
          if (IsMinus_Power == -1) {  
            i2 = 1 / i2;  
          };  
          rltFloat = i1 * i2;  
          rltFloat = iMinus * rltFloat;  
        }  
      } else if (sErrorCharSet == '.E') {  
        //前面是小数,后面是科学计数法  
        if ((myStr.indexOf('.') == 0) || (myStr.indexOf('E') == (myStr.length - 1))) {  
          //小数点在第1位,或者E在最后一位  
          rltBool = false;  
        } else if ((myStr.indexOf('E') - myStr.indexOf('.')) == 1) {  
          //小数点和E紧密相隔,中间无任何数字  
          rltBool = false;  
        } else {  
          rltBool = true;  
          i1 = parseFloat(myStr.substr(0, myStr.indexOf('E')));  
          i2 = Math.pow(10, parseFloat(myStr.substr(myStr.indexOf('E') + 1)));  
          if (IsMinus_Power == -1) {  
            i2 = 1 / i2;  
          };  
          rltFloat = i1 * i2;  
          rltFloat = iMinus * rltFloat;  

        }  
      } else {  

        rltBool = false;  

      }  
    }  

  }  

  return rltFloat;  
};  

function StrToIntDef(myStr, iIntDef) {  
  var rltInt;  
  rltInt=StrToInt(myStr);  

  if (isNaN(rltInt))  {  
    rltInt = iIntDef;  
  }  
  return rltInt;    
};  

function StrToFloatDef(myStr, iFloatDef) {  
  var rltFloat;  
  rltFloat=StrToFloat(myStr);  

  if (isNaN(rltFloat))  {  
    rltFloat = iFloatDef;  
  }  
  return rltFloat;    
};

要回复问题请先登录或注册

在HBuilderX的javaScript中,如保尝试将字符转化为数字, 比如: 将字符"55e2a"

4 个回复

公告

相关问题

在HBuilderX的javaScript中,如保尝试将字符转化为数字, 比如: 将字符"55e2a"

与内容相关的链接

4 个回复

公告

相关问题