zoukankan      html  css  js  c++  java
  • 模拟Visual Studio中的完全匹配查找

    模拟Visual Studio中的完全匹配查找
     
    public enum EnumDataType
        {
            中文 = 0,
            英文 = 1,
            数字 = 2,
            特殊字符 = 3,
            中文与特殊字符 = 4,
            英文与数字 = 5,
        }
    
    public static class CharExtend
        {
            /// <summary>
            /// 获得该字符类型
            /// </summary>
            /// <param name="item"></param>
            /// <returns></returns>
            public static EnumDataType GetDataType(this char item)
            {
                //范围(0x4e00~0x9fff)转换成int(ch-from~ch-end)
                int chfrom = Convert.ToInt32("4e00", 16);
                int chend = Convert.ToInt32("9fff", 16);
    
    
                if (item >= '0' && item <= '9')
                    return EnumDataType.数字;
                else if (item >= 'A' && item <= 'z')
                    return EnumDataType.英文;
                else
                {
                    int code = Char.ConvertToUtf32(item.ToString(), 0);
                    if (code >= chfrom && code <= chend)
                        return EnumDataType.中文;
                    else
                        return EnumDataType.特殊字符;
                }
            }
        }
    
    public static class BoolExtend
        {
            public static bool IsTrue(this bool bl)
            {
                return bl==true;
            }
    
            public static bool IsFalse(this bool bl)
            {
                return bl == false;
            }
        }
    
    /// <summary>
            /// 查找字符串strB在strA中的起止索引
            /// </summary>
            /// <param name="strA">被查找的字符串</param>
            /// <param name="strB">要查找的字符串</param>
            /// <returns>int值,没找到这返回-1</returns>
            public static int IndexOf(string strA, string strB)
            {
                return strA.IndexOf(strB);
            }
    
    /// <summary>
            /// 查找字符串strB在strA中的起止索引(模拟Visual Studio查找)
            /// </summary>
            /// <param name="strA">被查找的字符串</param>
            /// <param name="strB">要查找的字符串</param>
            /// <param name="fullMatched">是否全字匹配(true/false)</param>
            /// <returns>int值,没找到这返回-1</returns>
            public static int IndexOf(string strA, string strB, bool fullMatched)
            {
                /*
                 * 如果要查找的是中文、特殊符号,则完全匹配与非完全匹配结果一样
                 * 
                 * 如果要查找的是英文、数字,则需做特殊处理(完全匹配格式【其他】【英文/数字】【其他】
                 * 即还需匹配前后字符类型必须与要查找的类型不同
                 * 
                 */
    
                //如果要查字符串长度大于被查找字符串,则直接返回-1
                if (strB.Length > strA.Length)
                    return -1;
    
                EnumDataType[] types = new EnumDataType[2];
                if (fullMatched.IsTrue())
                {
                    #region MyRegion
                    if ((strB[0].GetDataType() == EnumDataType.中文 || strB[0].GetDataType() == EnumDataType.特殊字符))
                    {
                        types[0] = EnumDataType.中文与特殊字符;
                    }
                    else
                    {
                        types[0] = EnumDataType.英文与数字;
                    }
    
                    if ((strB[strB.Length - 1].GetDataType() == EnumDataType.中文 || strB[strB.Length - 1].GetDataType() == EnumDataType.特殊字符))
                    {
                        types[1] = EnumDataType.中文与特殊字符;
                    }
                    else
                    {
                        types[1] = EnumDataType.英文与数字;
                    } 
                    #endregion
                }
    
                int index = -1;
                if (strA.Length > 1)
                {
                    for (int i = 0; i <= strA.Length - strB.Length; i++)
                    {
                        //每次在strAight中取等长的字符串与strB比较,判断是否相等
                        if (strA.Substring(i, strB.Length) == strB)
                        {
                            //不是全字匹配
                            if (fullMatched.IsFalse())
                            {
                                //strB在strA中的找到的第一个匹配的起始索引为i
                                index = i;
                                break;
                            }
                            else//是全字匹配
                            {
                                //判断变量i是开始还是结束
                                if (i > 0 && i < strA.Length - strB.Length)
                                {
                                    #region MyRegion
                                    //匹配项前后第一个字符都不是字母和数字
                                    char start = strA.Substring(i - 1, 1)[0];
                                    char end = strA.Substring(i + strB.Length, 1)[0];
    
                                    EnumDataType startType=start.GetDataType();
                                    EnumDataType endType = end.GetDataType();
    
                                    if (types[0] == EnumDataType.中文与特殊字符)
                                    { }
                                    else if (types[0] == EnumDataType.英文与数字 && startType != EnumDataType.英文 && startType != EnumDataType.数字)
                                    { }
                                    else
                                    {
                                        continue;
                                    }
    
                                    if (types[1] == EnumDataType.中文与特殊字符)
                                    { }
                                    else if (types[1] == EnumDataType.英文与数字 && endType != EnumDataType.英文 && endType != EnumDataType.数字)
                                    { }
                                    else
                                    {
                                        continue;
                                    }
    
                                    //通关后找到索引
                                    index = i;//是全字匹配
                                    break; 
                                    #endregion
                                }
                                else if (i == 0)//如果是开始
                                {
                                    #region MyRegion
                                    if (i + strB.Length >= strA.Length)
                                    {
                                        index = i;//是全字匹配
                                        break;
                                    }
                                    else
                                    {
                                        char end = strA.Substring(i + strB.Length, 1)[0];
                                        EnumDataType endType = end.GetDataType();
    
                                        if (types[1] == EnumDataType.中文与特殊字符)
                                        { }
                                        else if (types[1] == EnumDataType.英文与数字 && endType != EnumDataType.英文 && endType != EnumDataType.数字)
                                        { }
                                        else
                                        {
                                            continue;
                                        }
    
                                        index = i;//是全字匹配
                                        break;
                                    }
                                    #endregion
                                }
                                else if (i == strA.Length - strB.Length)//如果是结束
                                {
                                    #region MyRegion
                                    char start = strA.Substring(i - 1, 1)[0];
                                    EnumDataType startType = start.GetDataType();
    
                                    if (types[0] == EnumDataType.中文与特殊字符)
                                    { }
                                    else if (types[0] == EnumDataType.英文与数字 && startType != EnumDataType.英文 && startType != EnumDataType.数字)
                                    { }
                                    else
                                    {
                                        continue;
                                    }
    
                                    index = i;//是全字匹配
                                    break; 
                                    #endregion
                                }
                            }
                        }
                    }
                }
                else
                {
                    if (strA == strB)
                        index = 0;
                }
                return index;
            }
    
    static void Main(string[] args)
            {
                TestIndexOf();
                Console.Read();
            }
    
    static void TestIndexOf()
            {
                string go = string.Empty;
                do
                {
                    Console.WriteLine("请输入要被查找的字符串");
                    string strA = Console.ReadLine();
                    Console.WriteLine("请输入要查找的字符串");
                    string strB = Console.ReadLine();
                    Console.WriteLine("是否全字匹配(Y/N)?");
                    string matched = Console.ReadLine().ToLower();
                    Console.WriteLine("内置的函数返回的索引值:" + IndexOf(strA, strB));
                    Console.WriteLine("自定义函数返回的索引值:" + IndexOf(strA, strB, matched == "y" ? true : false));
                    Console.WriteLine("是否继续(Y/N)?");
                    go = Console.ReadLine().ToLower();
                }
                while (go == "y");
            }
    

     转载请注明出处:http://www.cnblogs.com/jzblogs/p/5670397.html

  • 相关阅读:
    如何解决MathPage.wll或MathType.dll文件找不到问题
    2-构建模型
    R语言 ur.df函数(2)
    平稳过程趋势项变点的 CUSUV 检验 秦瑞兵,郭娟
    时间序列的弱相依与强相依
    Cent OS|使用httpd发布网页
    C++练习 | 基于栈的中缀算术表达式求值(double类型
    C++练习 | 不使用头插法逆转单链表
    C++练习 | 单链表的创建与输出(结构体格式)
    C++练习 | 最长公共字符串(DP)
  • 原文地址:https://www.cnblogs.com/jzblogs/p/5670397.html
Copyright © 2011-2022 走看看