タグ : チェック

 

.NET 文字列がJIS X 0208 漢字第二水準までで構成されているかをチェックする

C#、VB.NETで文字列がJIS X 0208 漢字第二水準までで構成されていることをチェックします。
 
最近のWEBサイトは文字コードをUnicodeで作成するため、文字化けを考慮することは少なくなってきましたが、一昔前までは文字列をWindowsとMac両方で文字化けなく表示させるため、入力できる文字に制限を付けることが一般的でした。
 
その際よく用いられるのが「JIS漢字第二水準まで許可」という仕様です。これは『半角英数字記号、全角記号・特殊文字、数字、ラテン文字、ひらがな、カタカナ、ギリシャ文字、キリル文字、罫線素片、漢字第1水準、漢字第2水準』で構成された文字列かどうかを判定します。
 
現在でも基幹系システムとの連携やラベルプリンタへの出力などで、丸付き数字やはしご高が文字化けする例が散見されますので、チェックのやり方は知っておくべきです。
 
●文字列がJIS X 0208 漢字第二水準までで構成されているかをチェック
        /// <summary>
        /// 文字列が半角英数字記号かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が半角英数字記号の場合はtrue、それ以外はfalse</returns>
        public static bool IsASCII(string target)
        {
            return new Regex("^[\x20-\x7E]+$").IsMatch(target);
        }

        /// <summary>
        /// 文字列が半角カタカナ(句読点~半濁点)かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が半角カタカナ(句読点~半濁点)の場合はtrue、それ以外はfalse</returns>
        public static bool IsHalfKatakanaPunctuation(string target)
        {
            return new Regex("^[\uFF61-\uFF9F]+$").IsMatch(target);
        }

        /// <summary>
        /// 文字列がJIS X 0208 漢字第二水準までで構成されているかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <param name="containsHalfKatakana">漢字第二水準までに半角カタカナを含む場合はtrue、それ以外はfalse</param>
        /// <returns>文字列がJIS X 0208 漢字第二水準までで構成されている場合はtrue、それ以外はfalse</returns>
        public static bool IsUntilJISKanjiLevel2(string target, bool containsHalfKatakana)
        {
            // 文字エンコーディングに「iso-2022-jp」を指定
            Encoding encoding = Encoding.GetEncoding("iso-2022-jp");

            // 文字列長を取得
            int length = target.Length;

            for (int i = 0; i < length; i++)
            {
                // 対象の部分文字列を取得
                string targetSubString = target.Substring(i, 1);

                // 半角英数字記号の場合
                if (IsASCII(targetSubString) == true)
                {
                    continue;
                }

                // 漢字第二水準までに半角カタカナを含まずかつ対象の部分文字列が半角カタカナの場合
                if (containsHalfKatakana == false &&
                    IsHalfKatakanaPunctuation(targetSubString) == true)
                {
                    return false;
                }

                // 対象部分文字列の文字コードバイト配列を取得
                byte[] targetBytes = encoding.GetBytes(targetSubString);

                // 要素数が「1」の場合は漢字第三水準以降の漢字が「?」に変換された
                if (targetBytes.Length == 1)
                {
                    return false;
                }

                // 文字コードバイト配列がJIS X 0208 漢字第二水準外の場合
                if (IsUntilJISKanjiLevel2(targetBytes) == false)
                {
                    return false;
                }
            }

            return true;
        }

        /// <summary>
        /// 文字列がJIS X 0208 漢字第二水準までで構成されているかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列がJIS X 0208 漢字第二水準までで構成されている場合はtrue、それ以外はfalse</returns>
        /// <remarks>句読点~半濁点の半角カタカナはJIS X 0208 漢字第二水準外と判定します</remarks>
        public static bool IsUntilJISKanjiLevel2(string target)
        {
            return IsUntilJISKanjiLevel2(target, false);
        }

        /// <summary>
        /// 文字コードバイト配列がJIS X 0208 漢字第二水準までであるかを判定します
        /// </summary>
        /// <param name="targetBytes">文字コードバイト配列</param>
        /// <returns>文字コードバイト配列がJIS X 0208 漢字第二水準までである場合はtrue、それ以外はfalse</returns>
        private static bool IsUntilJISKanjiLevel2(byte[] targetBytes)
        {
            // 文字コードバイト配列の要素数が8ではない場合
            if (targetBytes.Length != 8)
            {
                return false;
            }

            // 区を取得
            int row = targetBytes[3] - 0×20;

            // 点を取得
            int cell = targetBytes[4] - 0×20;

            switch (row)
            {
                case 1: // 1区の場合
                    if (1 <= cell && cell <= 94)
                    {
                        // 1点~94点の場合
                        return true;
                    }

                    break;

                case 2: // 2区の場合
                    if (1 <= cell && cell <= 14)
                    {
                        // 1点~14点の場合
                        return true;
                    }
                    else if (26 <= cell && cell <= 33)
                    {
                        // 26点~33点の場合
                        return true;
                    }
                    else if (42 <= cell && cell <= 48)
                    {
                        // 42点~48点の場合
                        return true;
                    }
                    else if (60 <= cell && cell <= 74)
                    {
                        // 60点~74点の場合
                        return true;
                    }
                    else if (82 <= cell && cell <= 89)
                    {
                        // 82点~89点の場合
                        return true;
                    }
                    else if (cell == 94)
                    {
                        // 94点の場合
                        return true;
                    }

                    break;

                case 3: // 3区の場合
                    if (16 <= cell && cell <= 25)
                    {
                        // 16点~25点の場合
                        return true;
                    }
                    else if (33 <= cell && cell <= 58)
                    {
                        // 33点~58点の場合
                        return true;
                    }
                    else if (65 <= cell && cell <= 90)
                    {
                        // 65点~90点の場合
                        return true;
                    }

                    break;

                case 4: // 4区の場合
                    if (1 <= cell && cell <= 83)
                    {
                        // 1点~83点の場合
                        return true;
                    }

                    break;

                case 5: // 5区の場合
                    if (1 <= cell && cell <= 86)
                    {
                        // 1点~86点の場合
                        return true;
                    }

                    break;

                case 6: // 6区の場合
                    if (1 <= cell && cell <= 24)
                    {
                        // 1点~24点の場合
                        return true;
                    }
                    else if (33 <= cell && cell <= 56)
                    {
                        // 33点~56点の場合
                        return true;
                    }

                    break;

                case 7: // 7区の場合
                    if (1 <= cell && cell <= 33)
                    {
                        // 1点~33点の場合
                        return true;
                    }
                    else if (49 <= cell && cell <= 81)
                    {
                        // 49点~81点の場合
                        return true;
                    }

                    break;

                case 8: // 8区の場合
                    if (1 <= cell && cell <= 32)
                    {
                        // 1点~32点の場合
                        return true;
                    }

                    break;

                default:
                    if (16 <= row && row <= 46) // 16区~46区の場合
                    {
                        if (1 <= cell && cell <= 94)
                        {
                            // 1点~94点の場合
                            return true;
                        }
                    }
                    else if (row == 47) // 47区の場合
                    {
                        if (1 <= cell && cell <= 51)
                        {
                            // 1点~51点の場合
                            return true;
                        }
                    }
                    else if (48 <= row && row <= 83) // 48区~83区の場合
                    {
                        if (1 <= cell && cell <= 94)
                        {
                            // 1点~94点の場合
                            return true;
                        }
                    }
                    else if (row == 84) // 84区の場合
                    {
                        if (1 <= cell && cell <= 6)
                        {
                            // 1点~6点の場合
                            return true;
                        }
                    }

                    break;
            }

            return false;
        }
 
 
Unicodeと日本語(JIS)では漢字の並び順が異なるため、正規表現での範囲指定は利用できません。愚直に一文字ずつ「JIS X 0208」に準拠しているかを判定しています。判定の基準とさせていただいた区・点の情報は、以下のサイトを参考にしております。
 
 
以下のエリアでは「IsUntilJISKanjiLevel2」メソッドを実際に動かした時の挙動を確認できます。
 
●半角カタカナはJIS X 0208 漢字第二水準外
IsUntilJISKanjiLevel2(" 
 ");           
実行結果:
 
●半角カタカナをJIS X 0208 漢字第二水準に含めるかを選択
IsUntilJISKanjiLevel2(" 
 ", 
 );
 
実行結果:
 

.NET 文字列が半角であるかをチェックする

C#、VB.NETで文字列が半角であることをチェックします。まずは一般的な文字列の「長さ」と「バイト数」が等しいことで判定する方法を説明します。
 
文字列が半角であるかをチェック(長さで判定)
 
        /// <summary>
        /// 文字列が半角かどうかを判定します
        /// </summary>
        /// <remarks>半角の判定を長さで行います</remarks>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が半角の場合はtrue、それ以外はfalse</returns>
        public static bool IsHalfByLength(string target)
        {
            return target.Length == Encoding.GetEncoding("shift_jis").GetByteCount(target);
        }
 
 
文字列の長さとシフトJISでの文字列のバイト数が等しい場合は半角とみなします。これでほとんどの要件は満たすことができると思いますが、たとえば『半角カナは「ヲ」~半濁点までを有効とする』といった要件が加わった場合は正規表現を使います。
 
文字列が半角であるかをチェック(正規表現で判定、半角カタカナは「ヲ」~半濁点までを有効とする)
 
        /// <summary>
        /// 文字列が半角かどうかを判定します
        /// </summary>
        /// <remarks>半角の判定を正規表現で行います。半角カタカナは「ヲ」~半濁点を半角とみなします</remarks>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が半角の場合はtrue、それ以外はfalse</returns>
        public static bool IsHalfByRegex(string target)
        {
            return new Regex("^[\u0020-\u007E\uFF66-\uFF9F]+$").IsMatch(target);
        }
 
 
以下のエリアでは「IsHalfByLength」と「IsHalfByRegex」メソッドを実際に動かした時の挙動を確認できます。
 
文字列が半角であるかをチェック(長さで判定)
 
IsHalfByLength(" 
 ");                   
実行結果:
 
文字列が半角であるかをチェック(正規表現で判定、半角カタカナは「ヲ」~半濁点までを有効とする)
 
IsHalfByRegex(" 
 ");                    
実行結果:
 

.NET 文字列が半角カタカナであるかをチェックする

C#、VB.NETで文字列が半角カタカナであることをチェックします。ユニコード表のどこからどこまでを半角カタカナとみなすかは要件によって異なりますが、ここでは句読点~半濁点と「ヲ」~半濁点を半角カタカナとみなすやりかたを説明します。
 
●文字列が半角カタカナ(句読点~半濁点)であるかをチェック
        /// <summary>
        /// 文字列が半角カタカナ(句読点~半濁点)かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が半角カタカナ(句読点~半濁点)の場合はtrue、それ以外はfalse</returns>
        public static bool IsHalfKatakanaPunctuation(string target)
        {
            return new Regex("^[\uFF61-\uFF9F]+$").IsMatch(target);
        }
 
 
●文字列が半角カタカナ(「ヲ」~半濁点)であるかをチェック
        /// <summary>
        /// 文字列が半角カタカナ(「ヲ」~半濁点)かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が半角カタカナ(「ヲ」~半濁点)の場合はtrue、それ以外はfalse</returns>
        public static bool IsHalfKatakana(string target)
        {
            return new Regex("^[\uFF66-\uFF9F]+$").IsMatch(target);
        }
 
 
以下のエリアでは「IsHalfKatakanaPunctuation」と「IsHalfKatakana」メソッドを実際に動かした時の挙動を確認できます。
 
●文字列が半角カタカナ(句読点~半濁点)であるかをチェック
IsHalfKatakanaPunctuation(" 
 ");   
実行結果:
 
●文字列が半角カタカナ(「ヲ」~半濁点)であるかをチェック
IsHalfKatakana(" 
 ");                   
実行結果:
 

.NET 文字列が英数字記号であるかをチェックする

C#、VB.NETで文字列が半角英数字記号であることをチェックします。今回は正規表現を利用してチェックする方法をご紹介します。
 
●文字列が半角英数字記号であるかをチェック
        /// <summary>
        /// 文字列が半角英数字記号かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が半角英数字記号の場合はtrue、それ以外はfalse</returns>
        public static bool IsASCII(string target)
        {
            return new Regex("^[\x20-\x7E]+$").IsMatch(target);
        }
 
 
以下のエリアでは「IsASCII」メソッドを実際に動かした時の挙動を確認できます。
 
●文字列が半角英数字記号であるかをチェック
IsASCII(" 
 ");    
実行結果:
 

.NET 文字列が英数字であるかをチェックする

C#、VB.NETで文字列が英数字であることをチェックします。正規表現を利用して小文字の英数字、大文字の英数字、英数字(大文字・小文字を区別しない)をチェックする方法をご紹介します。
 
●文字列が小文字の英数字であるかをチェック
        /// <summary>
        /// 文字列が小文字の英数字かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が小文字の英数字の場合はtrue、それ以外はfalse</returns>
        public static bool IsLowercaseAlphanumeric(string target)
        {
            return new Regex("^[0-9a-z]+$").IsMatch(target);
        }
 
 
●文字列が大文字の英数字であるかをチェック
        /// <summary>
        /// 文字列が大文字の英数字かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が大文字の英数字の場合はtrue、それ以外はfalse</returns>
        public static bool IsUppercaseAlphanumeric(string target)
        {
            return new Regex("^[0-9A-Z]+$").IsMatch(target);
        }
 
 
●文字列が英数字であるかをチェック
        /// <summary>
        /// 文字列が英数字かどうかを判定します
        /// </summary>
        /// <remarks>大文字・小文字を区別しません</remarks>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が英数字の場合はtrue、それ以外はfalse</returns>
        public static bool IsAlphanumeric(string target)
        {
            return new Regex("^[0-9a-zA-Z]+$").IsMatch(target);
        }
 
 
以下のエリアでは「IsLowercaseAlphanumeric」と「IsUppercaseAlphanumeric」、「IsAlphanumeric」メソッドを実際に動かした時の挙動を確認できます。
 
●文字列が小文字の英数字であるかをチェック
IsLowercaseAlphanumeric(" 
 ");    
実行結果:
 
●文字列が大文字の英数字であるかをチェック
IsUppercaseAlphanumeric(" 
 ");    
実行結果:
 
●文字列が英数字であるかをチェック
IsAlphanumeric(" 
 ");                  
実行結果:
 

.NET 文字列がアルファベットであるかをチェックする

C#、VB.NETで文字列が英字であることをチェックします。正規表現を利用して小文字の英字、大文字の英字、英字(大文字・小文字を区別しない)をチェックする方法をご紹介します。
 
●文字列が小文字のアルファベットであるかをチェック
        /// <summary>
        /// 文字列が小文字の英字かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が小文字の英字の場合はtrue、それ以外はfalse</returns>
        public static bool IsLowercaseAlphabet(string target)
        {
            return new Regex("^[a-z]+$").IsMatch(target);
        }
 
 
●文字列が大文字のアルファベットであるかをチェック
        /// <summary>
        /// 文字列が大文字の英字かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が大文字の英字の場合はtrue、それ以外はfalse</returns>
        public static bool IsUppercaseAlphabet(string target)
        {
            return new Regex("^[A-Z]+$").IsMatch(target);
        }
 
 
●文字列がアルファベットであるかをチェック
        /// <summary>
        /// 文字列が英字かどうかを判定します
        /// </summary>
        /// <remarks>大文字・小文字を区別しません</remarks>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が英字の場合はtrue、それ以外はfalse</returns>
        public static bool IsAlphabet(string target)
        {
            return new Regex("^[a-zA-Z]+$").IsMatch(target);
        }
 
 
以下のエリアでは「IsLowercaseAlphabet」と「IsUppercaseAlphabet」、「IsAlphabet」メソッドを実際に動かした時の挙動を確認できます。
 
●文字列が小文字のアルファベットであるかをチェック
IsLowercaseAlphabet(" 
 ");    
実行結果:
 
●文字列が大文字のアルファベットであるかをチェック
IsUppercaseAlphabet(" 
 ");    
実行結果:
 
●文字列がアルファベットであるかをチェック
IsAlphabet(" 
 ");                  
実行結果:
 

.NET 文字列が数値であるかをチェックする

C#、VB.NETで文字列が小数を含む数値に変換できるかをチェックします。今回は正規表現を利用して符号なし数値、符号あり数値をチェックする方法をご紹介します。
 
●文字列が符号なし数値(小数を含む)であるかをチェック
        /// <summary>
        /// 文字列が符号なしの小数かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が符号なしの小数の場合はtrue、それ以外はfalse</returns>
        public static bool IsUnsignedDecimal(string target)
        {
            return new Regex("^[0-9]*\\.?[0-9]+$").IsMatch(target);
        }
 
 
●文字列が符号あり数値(小数を含む)であるかをチェック
        /// <summary>
        /// 文字列が符号ありの小数かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が符号ありの小数の場合はtrue、それ以外はfalse</returns>
        public static bool IsDecimal(string target)
        {
            return new Regex("^[-+]?[0-9]*\\.?[0-9]+$").IsMatch(target);
        }
 
 
以下のエリアでは「IsUnsignedDecimal」と「IsDecimal」メソッドを実際に動かした時の挙動を確認できます。
 
●文字列が符号なし数値(小数を含む)であるかをチェック
IsUnsignedDecimal(" 
 ");    
実行結果:
 
●文字列が符号あり数値(小数を含む)であるかをチェック
IsDecimal(" 
 ");                 
実行結果:
 

.NET 文字列が整数であるかをチェックする

C#、VB.NETで文字列が整数に変換できるかをチェックする方法は何種類かありますが、ここでは正規表現を利用して符号なし整数、符号あり整数をチェックする方法をご紹介します。
 
●文字列が符号なし整数であるかをチェック
        /// <summary>
        /// 文字列が符号なしの整数かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が符号なしの整数の場合はtrue、それ以外はfalse</returns>
        public bool IsUnsignedIntegers(string target)
        {
            return new Regex("^[0-9]+$").IsMatch(target);
        }
 
 
●文字列が符号あり整数であるかをチェック
        /// <summary>
        /// 文字列が符号ありの整数かどうかを判定します
        /// </summary>
        /// <param name="target">対象の文字列</param>
        /// <returns>文字列が符号ありの整数の場合はtrue、それ以外はfalse</returns>
        public bool IsIntegers(string target)
        {
            return new Regex("^[-+]?[0-9]+$").IsMatch(target);
        }
 
 
以下のエリアでは「IsUnsignedIntegers」と「IsIntegers」メソッドを実際に動かした時の挙動を確認できます。
 
●文字列が符号なし整数であるかをチェック
IsUnsignedIntegers(" 
 ");    
実行結果:
 
●文字列が符号あり整数であるかをチェック
IsIntegers(" 
 ");                 
実行結果:
g h T
 25,825 Total Views