문자열에서 특수 문자를 제거하는 가장 효율적인 방법

문자열에서 모든 특수 문자를 제거하고 싶습니다. 허용되는 문자는 AZ (대문자 또는 소문자), 숫자 (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 자 정도의 짧은 길이입니다.

왜 당신의 방법이 비효율적이라고 생각합니까? 실제로 가장 효율적인 방법 중 하나입니다.

물론 문자를 로컬 변수로 읽거나 열거자를 사용하여 배열 액세스 수를 줄여야합니다.

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();
}

이와 같은 방법을 효율적으로 만드는 것은 확장 성이 뛰어나다는 것입니다. 실행 시간은 문자열 길이를 기준으로합니다. 큰 줄에 사용하면 놀라운 놀라움이 없습니다.

편집 :
빠른 성능 테스트를 수행하여 24 개의 문자열로 각 기능을 백만 번 실행했습니다. 결과는 다음과 같습니다.

원래 기능 : 54.5ms
내 제안 된 변경 사항 : 47.1 ms.
StringBuilder 용량을 설정 한 광산 : 43.3ms
정규식 : 294.4ms

편집 2 : 위 코드에서 AZ와 az의 차이점을 추가했습니다. (성능 테스트를 다시 실행했으며 눈에 띄는 차이는 없습니다.)

편집 3 :
lookup + char [] 솔루션을 테스트했으며 약 13ms에서 실행됩니다.

물론 지불해야 할 가격은 거대한 조회 테이블을 초기화하고 메모리에 유지하는 것입니다. 글쎄, 그것은 그렇게 많은 데이터는 아니지만 그런 사소한 기능을위한 것입니다 ...

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의 용량을 입력 문자열의 길이로 초기화하려고합니다. 재 할당을 피할 수 있습니다. 이 두 가지 방법을 함께 사용하면 속도와 유연성이 모두 향상됩니다.

다른 편집

컴파일러가 최적화 할 수 있다고 생각하지만 효율성뿐만 아니라 스타일 측면에서도 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());
}

이 접근 방식을 이전의 "빠른"접근 방법 두 가지 (릴리스 컴파일)와 비교했습니다.

• LukeH의 문자 배열 솔루션-427ms
• StringBuilder 솔루션-429ms
• LINQ (이 답변)-98ms

알고리즘은 약간 수정되었습니다. 문자는 하드 코딩되지 않고 배열로 전달되므로 약간 영향을 줄 수 있습니다 (즉, 다른 솔루션은 문자 배열을 확인하기 위해 내부 foor 루프가 있음).

LINQ where 절을 사용하여 하드 코딩 된 솔루션으로 전환하면 결과는 다음과 같습니다.

• 문자 배열 솔루션-7ms
• StringBuilder 솔루션-22ms
• LINQ-60ms

문자 목록을 하드 코딩하는 대신보다 일반적인 솔루션을 작성하려는 경우 LINQ 또는 수정 된 접근 방식을 살펴볼 가치가 있습니다. LINQ는 Regex보다 간결하고 읽기 쉬운 코드를 제공합니다.

알고리즘이 효율적이라고 확신하지는 않습니다. O (n)이며 각 문자를 한 번만 봅니다. 값을 확인하기 전에 마술처럼 값을 알지 않는 한 그 이상을 얻지 못할 것입니다.

그러나 나는 당신의 용량을 StringBuilder문자열의 초기 크기로 초기화 할 것 입니다. 귀하의 인식 성능 문제가 메모리 재 할당에서 비롯된 것 같습니다.

참고 : 점검 A- z안전하지 않습니다. 당신은 포함하고 [, \, ], ^, _,와`...

참고 2 : 효율성을 높이려면 비교 횟수를 최소화하기 위해 비교를 순서대로 수행하십시오. (최악의 경우, 8 개의 비교를 말하고 있으므로 너무 열심히 생각하지 마십시오.) 이것은 예상되는 입력에 따라 변경되지만 한 가지 예는 다음과 같습니다.

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();

실험 해 주셔서 감사합니다.

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();
        }
}

String Replace를 정규 표현식으로 사용하여 "특수 문자"를 검색하고 찾은 모든 문자를 빈 문자열로 바꿉니다.

나는 일을 위해 비슷한 것을해야했지만 내 경우에는 문자, 숫자 또는 공백이 아닌 모든 것을 필터링해야했습니다 (그러나 필요에 따라 쉽게 수정할 수 있습니다). 필터링은 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();
}

Linq에 의한 S & G의 경우 :

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
}