19 正则表达式的匹配 （第3章 高质量的代码-代码的完整性）

class Solution {
public:
    bool match(char* str,char* pattern)
    {
        if(str==nullptr || pattern==nullptr)
            return false;
        return matchCore( str,pattern);
    }
    
     bool matchCore(char* str,char* pattern)
    {
        if(*str==‘\0‘ && *pattern==‘\0‘)
            return true;  //是&&而不是||，要同时满足
        if(*str!=‘\0‘ && *pattern==‘\0‘)
            return false;
        //*str==‘\0‘ || *pattern!=‘\0‘   需要进行判断，因为*可以使字符重复0次
        //*str!=‘\0‘ || *pattern!=‘\0‘   需要进行判断
         
         //第二个字符是‘*‘时
         if(*(pattern+1)==‘*‘){
             //若字符匹配
             if(*str==*pattern || (*pattern==‘.‘ && *str!=‘\0‘)){  //两种匹配模式，满足任意一个都可以
                 return  matchCore( str+1,pattern) //*重复>1次
                     || matchCore( str+1,pattern+2) //*重复1次
                     || matchCore( str,pattern+2);//*重复0次
             }else{
                 //若字符不匹配 *使前面的字符重复0次，模式后移2个字符
                 return matchCore( str,pattern+2);
             }
         }
         
         //第二个字符不是‘*‘时
         //若第一个字符匹配，则继续判断下一个字符
         if(*str==*pattern || (*pattern==‘.‘ && *str!=‘\0‘))  //字符匹配有两种情况：1 字符相等，2 模式含有‘.‘。
             return matchCore( str+1,pattern+1);
         //字符不匹配
         return false;
    
    }
};

dao层try{}catch{}会影响事务的完整性吗

fast-serialization 反序列化时缺少字节数据的完整性检查

先一段简单的测试代码，看看fast-serialization在反序列化时缺少数据完整性检查是什么样一个情况：

//对字符串Hello World进行反序列化
 String str = "Hello World !";
 FSTConfiguration conf = FSTConfiguration.getDefaultConfiguration();
 ByteArrayOutputStream outStream = new ByteArrayOutputStream();
 conf.getObjectOutput(outStream).writeObject(str);
 byte[] bytes = outStream.toByteArray();


 //此处模拟数据失真，故意只截取序列化结果中的一部分数据
 byte[] copy = new byte[bytes.length - 5];
 System.arraycopy(bytes, 0, copy, 0, copy.length);


 //对失真的序列化结果进行反序列化，反序列化过程中并没有抛出异常
 ByteArrayInputStream inStream = new ByteArrayInputStream(copy);
 str = (String) conf.getObjectInput(inStream).readObject();
 
 System.out.println(str);

以上代码输出结果为“Hello Wo     ”。

咋一看似乎一切正常，因为故意截取了5个字节，所以反序列化的输出结果中丢失了5个字符，这样反序列化后的结果就失真了。

可仔细想想就发现不对的地方，如果是丢失了5个字节的话，输出结果应该是“Hello Wo”-8个字符，而不是“Hello Wo+5个空格“-13个字符，既然FST知道序列化时字符串length是13个字符，那为何没有因为反序列化的字节数据不完整而抛出异常，反而输出了一个失真的结果呢？

以上问题，最终在de.ruedigermoeller.serialization.util.FSTInputStream和de.ruedigermoeller.serialization.FSTObjectInput类中找到了答案:

public final class FSTInputStream extends InputStream {
    public int chunk_size = 1000;
    ... ...
    public void initFromStream(InputStream in) {
        try {
            this.in = in;
            if (buf==null) {
                buf = cachedBuffer.get();
                if ( buf == null ) {
                    buf = new byte[chunk_size];
                    cachedBuffer.set(buf);
                }
            }
            int read = in.read(buf);
            count+=read;
            //1.将所有反序列化的字节数据读取到本地的buffer中
            while( read != -1 ) {
                try {
                    //实际字节数据大小超出buffer容量时，buffer扩充到目前的2倍，默认是每次扩充1000个字节
                    //所以buffer中的字节数据并不都是有效数据
                    if ( buf.length < count+chunk_size ) {
                        ensureCapacity(buf.length*2);
                    }
                    read = in.read(buf,count,chunk_size);
                    if ( read > 0 )
                        count += read;
                } catch ( IndexOutOfBoundsException iex ) {
                    read = -1; // many stream impls break contract
                }
            }
            in.close();
        } catch (IOException e) {
            FSTUtil.rethrow(e);
        }
    }
    ... ...
｝

public class FSTObjectInput extends DataInputStream implements ObjectInput {
   ... ...
   FSTInputStream input;
   ... ...
   public String readStringUTF() throws IOException {
        //2.获取反序列化的字符串长度
        int len = readCInt();
        char[] charBuf = getCharBuf(len*3);
        ensureReadAhead(len * 3);
        byte buf[] = input.buf;
        int count = input.pos;
        int chcount = 0;
        //3.以下是对字符串进行反序列化，首先从Input stream的buffer中读取到字符串的bytes数组，
        for (int i = 0; i < len; i++) {
             //这里从buffer中获取字节时并没有判断是否已经超出有效字节数据的范围
             //这就解释了为什么测试代码反序列化的结果是“Hello Wo     ”，是因为拿到无效的字节数据
            char head = (char) ((buf[count++] + 256) &0xff);
            if (head < 255) {
                charBuf[chcount++] = head;
            } else {
                int ch1 = ((buf[count++] + 256) &0xff);
                int ch2 = ((buf[count++] + 256) &0xff);
                charBuf[chcount++] = (char) ((ch1 << 8) + (ch2 << 0));
            }
        }
        input.pos = count;
        return new String(charBuf, 0, chcount);
    }
    ... ...
｝

js 对必填参数的完整性判断

// 参数判空 false不通过 true为通过
export const checkParamsIsNull = (params:object, noCheckedParamsArr: Array<string>) => {
  var arr = [];
  for (let item in params) {
    let listItem = {
      key: item,
      value: params[item]
    };
    if(noCheckedParamsArr.indexOf(listItem.key) < 0){
      arr.push(listItem);
    }
  }

  var resStrList = []
  for(let obj of arr){
    if (obj.value === null || obj.value === ''null'' || obj.value === undefined || obj.value === ''undefined'' || obj.value === '''' || obj.value.length === 0) {
      // TODO 开发时将参数的值打印出来，以便定位哪个参数为空
      swal({
        title: ''必填参数不能为空'',
        // title:obj.key + ''不能为空'',
        type:''error'',
        showConfirmButton: true
      });
      return false
    } else {
      resStrList.push(true)
    }
  }

  if(resStrList.indexOf(false) < 0){
    return true
  }
};

今天关于“anymatch”的完整性检查失败（计算的完整性与我们的记录不匹配，得到的分享就到这里，希望大家有所收获，若想了解更多关于19 正则表达式的匹配 （第3章 高质量的代码-代码的完整性）、dao层try{}catch{}会影响事务的完整性吗、fast-serialization 反序列化时缺少字节数据的完整性检查、js 对必填参数的完整性判断等相关知识，可以在本站进行查询。