文字列から特殊文字を削除する最も効率的な方法

文字列からすべての特殊文字を削除したい。使用できる文字は、A〜Z（大文字または小文字）、数字（0〜9）、下線（_）、またはドット記号（。）です。

私は以下を持っています、それは機能しますが、私は知っています（私は知っています！）それは非常に効率的ではありません：

    public static string RemoveSpecialCharacters(string str)
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < str.Length; i++)
        {
            if ((str[i] >= '0' && str[i] <= '9')
                || (str[i] >= 'A' && str[i] <= 'z'
                    || (str[i] == '.' || str[i] == '_')))
                {
                    sb.Append(str[i]);
                }
        }

        return sb.ToString();
    }

これを行う最も効率的な方法は何ですか？正規表現はどのように見え、通常の文字列操作とどのように比較しますか？

クリーンアップされる文字列はかなり短く、通常は10〜30文字の長さです。

なぜあなたの方法は効率的ではないと思いますか？それは実際にそれを行うことができる最も効率的な方法の1つです。

もちろん、文字をローカル変数に読み込むか、列挙子を使用して配列アクセスの数を減らす必要があります。

public static string RemoveSpecialCharacters(this string str) {
   StringBuilder sb = new StringBuilder();
   foreach (char c in str) {
      if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '.' || c == '_') {
         sb.Append(c);
      }
   }
   return sb.ToString();
}

このような方法を効率的にする1つのことは、拡張性が高いことです。実行時間は文字列の長さに比例します。大きなストリングで使用しても、意外な驚きはありません。

編集：
私は簡単なパフォーマンステストを行い、24文字の文字列で各関数を100万回実行しました。これらは結果です：

元の機能：54.5 ms。
私の提案する変更：47.1 ms。
StringBuilderの容量を設定した鉱山：43.3ミリ秒。
正規表現：294.4ミリ秒。

編集2：上記のコードでAZとazの区別を追加しました。（パフォーマンステストを再実行しましたが、目立った違いはありません。）

編集3：
lookup + char []ソリューションをテストしましたが、約13ミリ秒で実行されます。

もちろん、支払うべき代償は、巨大なルックアップテーブルを初期化してメモリに保持することです。まあ、それはそれほど多くのデータではありませんが、それはそのような些細な機能のためのものです...

private static bool[] _lookup;

static Program() {
   _lookup = new bool[65536];
   for (char c = '0'; c <= '9'; c++) _lookup[c] = true;
   for (char c = 'A'; c <= 'Z'; c++) _lookup[c] = true;
   for (char c = 'a'; c <= 'z'; c++) _lookup[c] = true;
   _lookup['.'] = true;
   _lookup['_'] = true;
}

public static string RemoveSpecialCharacters(string str) {
   char[] buffer = new char[str.Length];
   int index = 0;
   foreach (char c in str) {
      if (_lookup[c]) {
         buffer[index] = c;
         index++;
      }
   }
   return new string(buffer, 0, index);
}

まあ、実際に関数からパフォーマンスを絞り出す必要がない限り、メンテナンスと理解が最も簡単なものを選んでください。正規表現は次のようになります。

追加のパフォーマンスを得るには、プリコンパイルするか、最初の呼び出しでコンパイルするように指示するだけです（その後の呼び出しはより高速になります）。

public static string RemoveSpecialCharacters(string str)
{
    return Regex.Replace(str, "[^a-zA-Z0-9_.]+", "", RegexOptions.Compiled);
}

静的なコンストラクターで初期化して、文字の任意の組み合わせを有効に設定できる単純なルックアップテーブルを作成することをお勧めします。これにより、迅速な単一チェックを行うことができます。

編集する

また、速度を上げるために、StringBuilderの容量を入力文字列の長さに初期化する必要があります。これにより、再割り当てが回避されます。これら2つの方法を組み合わせると、速度と柔軟性の両方が得られます。

別の編集

コンパイラはそれを最適化するかもしれませんが、スタイルと効率の問題として、forの代わりにforeachをお勧めします。

public static string RemoveSpecialCharacters(string str)
{
    char[] buffer = new char[str.Length];
    int idx = 0;

    foreach (char c in str)
    {
        if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z')
            || (c >= 'a' && c <= 'z') || (c == '.') || (c == '_'))
        {
            buffer[idx] = c;
            idx++;
        }
    }

    return new string(buffer, 0, idx);
}

正規表現は次のようになります。

public string RemoveSpecialChars(string input)
{
    return Regex.Replace(input, @"[^0-9a-zA-Z\._]", string.Empty);
}

ただし、パフォーマンスが非常に重要な場合は、「正規表現パス」を選択する前にいくつかのベンチマークを行うことをお勧めします...

文字の動的なリストを使用している場合、LINQははるかに高速で優雅なソリューションを提供する可能性があります。

public static string RemoveSpecialCharacters(string value, char[] specialCharacters)
{
    return new String(value.Except(specialCharacters).ToArray());
}

このアプローチを以前の2つの「高速」アプローチ（リリースコンパイル）と比較しました。

• LukeHによるChar配列ソリューション-427 ms
• StringBuilderソリューション-429ミリ秒
• LINQ（この回答）-98 ms

アルゴリズムが少し変更されていることに注意してください。文字はハードコード化されるのではなく配列として渡されるため、少し影響を与える可能性があります（つまり、他のソリューションでは文字配列をチェックするために内部foorループがあります）。

LINQ where句を使用してハードコーディングされたソリューションに切り替えると、結果は次のようになります。

• Charアレイソリューション-7ms
• StringBuilderソリューション-22ms
• LINQ-60ミリ秒

文字のリストをハードコーディングするのではなく、より一般的なソリューションを書くことを計画している場合は、LINQまたは修正されたアプローチを検討する価値があるかもしれません。LINQは、簡潔で読みやすいコードを提供します-Regexよりもさらに優れています。

私はあなたのアルゴリズムが効率的ではないと確信していません。これはO（n）であり、各文字を一度だけ見ます。それらをチェックする前に魔法のように値を知らない限り、あなたはそれより良くなることはありません。

しかし、私はあなたの容量をStringBuilder文字列の初期サイズに初期化します。パフォーマンスの問題として認識されているのは、メモリの再割り当てにあると思います。

補足：チェックA- z安全ではありません。あなたは含めている[、\、]、^、_、と`...

注2：効率を上げるために、比較の数を最小限にするために比較を並べます。（最悪の場合、8つの比較について話しているので、あまり考えすぎないでください。）これは予想される入力によって変わりますが、1つの例は次のとおりです。

if (str[i] >= '0' && str[i] <= 'z' && 
    (str[i] >= 'a' || str[i] <= '9' ||  (str[i] >= 'A' && str[i] <= 'Z') || 
    str[i] == '_') || str[i] == '.')

サイドノート3：何らかの理由で本当にこれを高速にする必要がある場合は、switchステートメントの方が高速かもしれません。コンパイラーはジャンプテーブルを作成し、単一の比較のみを行います。

switch (str[i])
{
    case '0':
    case '1':
    .
    .
    .
    case '.':
        sb.Append(str[i]);
        break;
}

StringBuilder sb = new StringBuilder();

for (int i = 0; i < fName.Length; i++)
{
   if (char.IsLetterOrDigit(fName[i]))
    {
       sb.Append(fName[i]);
    }
}

次のように正規表現を使用できます。

return Regex.Replace(strIn, @"[^\w\.@-]", "", RegexOptions.None, TimeSpan.FromSeconds(1.0));

良さそうです。私が行う唯一の改善StringBuilderは、文字列の長さでを初期化することです。

StringBuilder sb = new StringBuilder(str.Length);

このコードサンプルに同意します。唯一の違いは、文字列型の拡張メソッドにします。非常に単純な行またはコードで使用できるように：

string test = "abc@#$123";
test.RemoveSpecialCharacters();

実験をしてくれたGuffaに感謝します。

public static class MethodExtensionHelper
    {
    public static string RemoveSpecialCharacters(this string str)
        {
            StringBuilder sb = new StringBuilder();
            foreach (char c in str)
            {
                if ((c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_')
                {
                    sb.Append(c);
                }
            }
            return sb.ToString();
        }
}

「特殊文字」を検索する正規表現で文字列置換を使用して、見つかったすべての文字を空の文字列で置き換えます。

仕事でも同様のことをしなければなりませんでしたが、私の場合は、文字、数字、空白以外のすべてをフィルタリングする必要がありました（ただし、必要に応じて簡単に変更できます）。フィルタリングはJavaScriptでクライアント側で行われますが、セキュリティ上の理由から、サーバー側でもフィルタリングを行っています。ほとんどの文字列がクリーンであることを期待できるので、本当に必要な場合を除いて、文字列をコピーすることは避けたいです。これにより、以下の実装が可能になり、クリーンな文字列とダーティな文字列の両方でパフォーマンスが向上するはずです。

public static string EnsureOnlyLetterDigitOrWhiteSpace(string input)
{
    StringBuilder cleanedInput = null;
    for (var i = 0; i < input.Length; ++i)
    {
        var currentChar = input[i];
        var charIsValid = char.IsLetterOrDigit(currentChar) || char.IsWhiteSpace(currentChar);

        if (charIsValid)
        {
            if(cleanedInput != null)
                cleanedInput.Append(currentChar);
        }
        else
        {
            if (cleanedInput != null) continue;
            cleanedInput = new StringBuilder();
            if (i > 0)
                cleanedInput.Append(input.Substring(0, i));
        }
    }

    return cleanedInput == null ? input : cleanedInput.ToString();
}

S＆GのLinq化された方法：

var original = "(*^%foo)(@)&^@#><>?:\":';=-+_";
var valid = new char[] { 
    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 
    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 
    'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 
    'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6', '7', '8', 
    '9', '0', '.', '_' };
var result = string.Join("",
    (from x in original.ToCharArray() 
     where valid.Contains(x) select x.ToString())
        .ToArray());

しかし、これが最も効率的な方法になるとは思いません。

public string RemoveSpecial(string evalstr)
{
StringBuilder finalstr = new StringBuilder();
            foreach(char c in evalstr){
            int charassci = Convert.ToInt16(c);
            if (!(charassci >= 33 && charassci <= 47))// special char ???
             finalstr.append(c);
            }
return finalstr.ToString();
}

使用する：

s.erase(std::remove_if(s.begin(), s.end(), my_predicate), s.end());

bool my_predicate(char c)
{
 return !(isalpha(c) || c=='_' || c==' '); // depending on you definition of special characters
}

そして、あなたはきれいな文字列を取得しますs。

erase()すべての特殊文字を取り除き、my_predicate()関数で高度にカスタマイズ可能です。

HashSetはO（1）
既存の比較よりも速いかどうか不明

private static HashSet<char> ValidChars = new HashSet<char>() { 'a', 'b', 'c', 'A', 'B', 'C', '1', '2', '3', '_' };
public static string RemoveSpecialCharacters(string str)
{
    StringBuilder sb = new StringBuilder(str.Length / 2);
    foreach (char c in str)
    {
        if (ValidChars.Contains(c)) sb.Append(c);
    }
    return sb.ToString();
}

私はテストし、これは受け入れられた答えよりも速くありません。
構成可能な一連の文字が必要であるかのように、これは適切な解決策になるので、そのままにしておきます。

正規表現ベースの置換（コンパイルされている可能性があります）の方が速いのでしょうか。誰かがこれが5倍遅いことを発見したことをテストする必要があります。

それ以外の場合は、予想される長さでStringBuilderを初期化する必要があります。そうすることで、中間文字列が成長している間にコピーする必要がなくなります。

適切な数値は、元の文字列の長さか、それよりも少し小さい値です（関数の入力の性質によって異なります）。

最後に、（0..127の範囲の）ルックアップテーブルを使用して、文字を受け入れるかどうかを確認できます。

次のコードの出力は次のとおりです（結論として、配列のサイズを小さくしてメモリリソースを節約することもできます）。

lookup = new bool[123];

for (var c = '0'; c <= '9'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

for (var c = 'A'; c <= 'Z'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

for (var c = 'a'; c <= 'z'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

48: 0  
49: 1  
50: 2  
51: 3  
52: 4  
53: 5  
54: 6  
55: 7  
56: 8  
57: 9  
65: A  
66: B  
67: C  
68: D  
69: E  
70: F  
71: G  
72: H  
73: I  
74: J  
75: K  
76: L  
77: M  
78: N  
79: O  
80: P  
81: Q  
82: R  
83: S  
84: T  
85: U  
86: V  
87: W  
88: X  
89: Y  
90: Z  
97: a  
98: b  
99: c  
100: d  
101: e  
102: f  
103: g  
104: h  
105: i  
106: j  
107: k  
108: l  
109: m  
110: n  
111: o  
112: p  
113: q  
114: r  
115: s  
116: t  
117: u  
118: v  
119: w  
120: x  
121: y  
122: z  

ロシア語のロケールをサポートする次のコード行を追加することもできます（配列サイズは1104になります）：

for (var c = 'А'; c <= 'Я'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

for (var c = 'а'; c <= 'я'; c++)
{
    lookup[c] = true; System.Diagnostics.Debug.WriteLine((int)c + ": " + (char)c);
}

それが最も効率的な方法かどうかはわかりませんが、私にとってはうまくいきます

 Public Function RemoverTildes(stIn As String) As String
    Dim stFormD As String = stIn.Normalize(NormalizationForm.FormD)
    Dim sb As New StringBuilder()

    For ich As Integer = 0 To stFormD.Length - 1
        Dim uc As UnicodeCategory = CharUnicodeInfo.GetUnicodeCategory(stFormD(ich))
        If uc <> UnicodeCategory.NonSpacingMark Then
            sb.Append(stFormD(ich))
        End If
    Next
    Return (sb.ToString().Normalize(NormalizationForm.FormC))
End Function

ここには多くの提案された解決策があり、いくつかは他よりも効率的ですが、おそらくあまり読みにくいかもしれません。以下は最も効率的ではないかもしれませんが、ほとんどの状況で確かに使用でき、Linqを活用して非常に簡潔で読みやすいものです。

string stringToclean = "This is a test.  Do not try this at home; you might get hurt. Don't believe it?";

var validPunctuation = new HashSet<char>(". -");

var cleanedVersion = new String(stringToclean.Where(x => (x >= 'A' && x <= 'Z') || (x >= 'a' && x <= 'z') || validPunctuation.Contains(x)).ToArray());

var cleanedLowercaseVersion = new String(stringToclean.ToLower().Where(x => (x >= 'a' && x <= 'z') || validPunctuation.Contains(x)).ToArray());

public static string RemoveSpecialCharacters(string str){
    return str.replaceAll("[^A-Za-z0-9_\\\\.]", "");
}

public static string RemoveAllSpecialCharacters(this string text) {
  if (string.IsNullOrEmpty(text))
    return text;

  string result = Regex.Replace(text, "[:!@#$%^&*()}{|\":?><\\[\\]\\;'/.,~]", " ");
  return result;
}

速度が心配な場合は、ポインタを使用して既存の文字列を編集してください。文字列を固定してポインタを取得し、各文字に対してforループを実行して、無効な文字をそれぞれ置換文字で上書きすることができます。これは非常に効率的で、新しい文字列メモリを割り当てる必要はありません。ポインターを使用するには、unsafeオプションを使用してモジュールをコンパイルし、メソッドヘッダーに「unsafe」修飾子を追加する必要もあります。

static void Main(string[] args)
{
    string str = "string!$%with^&*invalid!!characters";
    Console.WriteLine( str ); //print original string
    FixMyString( str, ' ' );
    Console.WriteLine( str ); //print string again to verify that it has been modified
    Console.ReadLine(); //pause to leave command prompt open
}


public static unsafe void FixMyString( string str, char replacement_char )
{
    fixed (char* p_str = str)
    {
        char* c = p_str; //temp pointer, since p_str is read-only
        for (int i = 0; i < str.Length; i++, c++) //loop through each character in string, advancing the character pointer as well
            if (!IsValidChar(*c)) //check whether the current character is invalid
                (*c) = replacement_char; //overwrite character in existing string with replacement character
    }
}

public static bool IsValidChar( char c )
{
    return (c >= '0' && c <= '9') || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c == '.' || c == '_');
    //return char.IsLetterOrDigit( c ) || c == '.' || c == '_'; //this may work as well
}