c# 문자열 처리

일반

//텍스트에서 A를 찾는다
int index = text.IndexOf("A");



//문자열 자르기
string text=nameof(speed);
string textSpe = text.Substring(startIndex:0, length:3); //spe
string textPee = text.Substring(startIndex:1, length:3); //pee
string textEed = text.Substring(startIndex:2); //eed


//숫자만 추출
text = new string(System.Array.FindAll(text.ToCharArray(), c => char.IsDigit(c)));


//숫자앞에 0붙이기
int num=7;
num.ToString("D3"); //7 -> 007 , 76 -> 076같이 3글자 숫자로 바꿔줌


//숫자앞에 0붙이기2
string text="7";
text.ToString().PadLeft(3,'0'); //7 -> 007 , 76 -> 076같이 3글자 숫자로 바꿔줌


//소숫점 자르기
7.014837f.ToString("N4"); //7.0148
7.014837f.ToString("N2"); //7.01


//text가 숫자인지 확인(bool반환)
string text="";
if(int.TryParse(text, out int num))
/*
    -결과 모음, int형에 부합하는것만 true를 반환
    A : False
    A1 : False
    1 : True
    1.0 : False
    001 : True
    1+1 : False
    2147483647 : True
    2147483648 : False

    -복합사용예제
    if (int.TryParse(text, out int num))
    {
        if (num > 5)
        {
        }
    }


*/


문자열을 int형으로 변환
int number = System.Int32.Parse(text);







//A~Z 랜덤 문자열
string randomChar = ((char)Random.Range('A', 'Z')).ToString();



//따옴표를 표기할때
Debug.Log(@"""A""");//"A"가 표시됨


//문자열을 ?형으로 변환
//일반적으로 리플렉션과 연동할때 사용

public static T StringArrayToClass<T>(string[] texts) where T : new()
{
    var fields = typeof(T).GetFields();
    var tempClass = new T();
    for (int i = 0; i < fields.Length; i++)
    {
        var field = fields[i];

        try
        {
            var converter = System.ComponentModel.TypeDescriptor.GetConverter(field.FieldType);
            var objData = converter.ConvertFrom(texts[i]);
            field.SetValue(tempClass, objData);
        }
        catch (System.Exception ex)
        {
            Debug.LogError(ex);
            Debug.LogError($"text:{texts[i]}");
            Debug.LogError($"field.Name:{field.Name}");
            Debug.LogError($"field.FieldType:{field.FieldType}");
            throw;
        }
    }
    return tempClass;
}

 

형변환

//char를 string으로 변환
string text= char.ToString();



//char[]를 string으로 변환
//절대로 toString()을 쓰면 안된다
string text= new string(chars);

//string을 char[]로 변환
char[] charArray= text.ToCharArray();



//키코드를 문자열로 바꿈
text=((KeyCode)key).ToString().Replace("Alpha", "");



//10진수 정수를 16진수 문자열로 바꿈
int num=61;
string hex = System.Convert.ToString(num, 16);
Debug.Log(hex); //결과 3d

//16진수 문자열을 10진수 정수로 바꿈
System.Int32.Parse(hex, System.Globalization.NumberStyles.HexNumber);





//문자열 배열을 문자열로 통합
string text=string.Concat(texts);


//문자열 배열을 사이에 엔터를 넣어가며 문자열로 통합
string text=string.Join("\n", texts);


//String to StringArray
//문자열을 잘라서 문자열 배열로 반환
//분할후 공백을 모두 제거
string text="line1 \n Line2"
string[] lines = text.Split(new char[] { '\r', '\n' },StringSplitOptions.RemoveEmptyEntries);

//String to StringArray2
//이번엔 string으로 구분값을 사용
var texts = text.Split(new string[] { ":--:" });

 

 

 

 

 

 

세줄 모두 같은 처리결과를 가진다

int count=0;
string t;
t="count: " + count;
t=$"count: {count}";
t=string.Format("count: {0}", count);

 

마지막 줄 코드는 틀니스러운 방법이다. 이젠 쓰이지 않는다

 

 

 

 

StringBuilder 예제

var sb = new System.Text.StringBuilder();
sb.AppendLine("AB");
sb.AppendLine("C");
Debug.Log(sb.ToString());

//결과: 
AB
C

var sb = new System.Text.StringBuilder();
sb.Append("AB");
sb.Append("C");
Debug.Log(sb.ToString());

//결과: 
ABC

 

 

앞에 @가 붙으면 입력받은 그대로 쓸수있게 해준다 가령 \n이 엔터가 아니라 그대로 보이게 해준다

파일주소를 그대로 넣을때도 사용한다

Debug.Log(@"\n보\n이\n냐\n?");
//결과: \n보\n이\n냐\n?

$와 @를 동시에 써야할때

int num=100;
Debug.Log($@"\n보\n인\n다{num}\n?");
//결과: \n보\n인\n다100\n?

 

 

 

 

 

Replace는 해당 문자가 들어있으면 지워버린다.

경로에 StreamingAssets/가 포함되어있으면 Streaming만 남으니 주의하자

Debug.Log("Assets/user.csv".Replace("Assets/",""));
//결과: user.csv

응용해서 띄어쓰기 지우기

Debug.Log("문자 테스트 입니다.".Replace(" ",""));
//결과: 문자테스트입니다.

 

 

Regex패턴들 (정규표현식)

@"^[a-zA-Z ',.?""!]+$" //일반적인 영어문장에 사용되는 패턴
@"^[0-9]+$" //숫자만
@"^[a-zA-Z]+$" //알파벳만

영어로만 이루어져있는지 검사

System.Text.RegularExpressions.Regex.IsMatch("ABC",@"^[a-zA-Z]+$"); //true
System.Text.RegularExpressions.Regex.IsMatch("한글",@"^[a-zA-Z]+$"); //false

지정한 문자열만 제거

System.Text.RegularExpressions.Regex.Replace("테스트@$%^", @"[^\w\.@-]", "") //결과:테스트

 

지정한 화이트리스트에 등록된 문자열만 통과

    public static string ReplaceWhiteList(string text,string regexPattern)//화이트리스트
    {
        if (string.IsNullOrWhiteSpace(text))
        {
            return text;
        }
        var convertText = new List<char>();
        for (int i = 0; i < text.Length; i++)
        {
            if(System.Text.RegularExpressions.Regex.IsMatch(text[i].ToString(), regexPattern))
            {
                convertText.Add(text[i]);
            }
        }
        if(convertText.Count==0)
        {
            return "";
        }
        else
        {
            return new string(convertText.ToArray());
        }
    }

 

앞글자를 대문자로 바꿈

int jumpSpeed=0;

{
    string text=nameof(speed);
    var textInfo = new System.Globalization.CultureInfo("en-US", false).TextInfo;
    string toUpperTitleLetter = textInfo.ToTitleCase(text);
    //toUpperTitleLetter는 Jumpspeed가 됨
}

{
    string text=nameof(speed);
    string toUpperFirstLetter = text.ToUpper()[0] + text.Substring(1, text.Length - 1);
    //toUpperFirstLetter는 JumpSpeed가 됨
}

 

 

 

 

 

 

 

 

 

 

 

 

소문자인지 체크

if (inputString==inputString.ToLower())

 

 

 

중복제거

using System.Linq;

var text = "ABCABD";
var filterText = new string(text.ToCharArray().Distinct().ToArray());
Debug.Log(filterText);
//결과 : ABCD

 

 

 

컬러텍스트 (유니티)

    public string ColorText(string text, Color color)
    {
        return $"<color=#{ColorUtility.ToHtmlStringRGB(color)}>{text}</color>";
    }

 

 

특정 문자의 사이즈와 컬러를 바꿈

 

심플타입

    public static string HighlightWord(string originalText, string highlightChar, Color highlightColor, int fontSize)
    {
        var convertText = originalText;
        convertText = convertText.Replace(highlightChar.ToLower(), highlightChar.ToUpper());
        convertText = convertText.Replace(highlightChar.ToUpper(), $"<size={fontSize}><color=#{ColorUtility.ToHtmlStringRGB(highlightColor)}>{highlightChar.ToUpper()}</color></size>");

        return convertText;

    }

 

해쉬키타입, 간단하지만 변경될 문자에 해쉬키의 일부가 있으면 안된다

    public static string HighlightWord(string originalText, string highlightChar, Color highlightColor, int fontSize)
    {
        var convertText = originalText;
        string hash = "&*&*&*&*&*&";
        for (int i = 0; i < 100; i++)
        {
            if (originalText.Contains(hash))
            {
                hash += $"Dummy{(int)Random.Range(0,100)}";
            }
            else
            {
                break;
            }
        }
        convertText = convertText.Replace(highlightChar.ToLower(), hash);
        convertText = convertText.Replace(highlightChar.ToUpper(), $"<size={fontSize}><color=#{ColorUtility.ToHtmlStringRGB(highlightColor)}>{highlightChar.ToUpper()}</color></size>");
        convertText = convertText.Replace(hash, highlightChar.ToLower());

        return convertText;

    }

 

레겍스 타입 (미완성임)

    public static string HighlightWord(string originalText, string highlightChar, Color highlightColor, int fontSize)
    {
        var convertText = originalText;
        var pattern = new System.Text.RegularExpressions.Regex($"^[{highlightChar.ToLower()}]|[{highlightChar.ToUpper()}]+$");
        return pattern.Replace(convertText, $"<size={fontSize}><color=#{ColorUtility.ToHtmlStringRGB(highlightColor)}>{highlightChar.ToUpper()}</color></size>");
    }

 

찾아낸 첫번째 문자만 하이라이트

    public static string HighlightWordFirstIndex(string originalText, string highlightChar, Color highlightColor, int fontSize)
    {
        var convertText = originalText;
        var firstIndexLower = originalText.IndexOf(highlightChar.ToLower());
        var firstIndexUpper = originalText.IndexOf(highlightChar.ToUpper());

        int firstIndex = -1;
        if (firstIndexLower==-1)
        {
            firstIndex = firstIndexUpper;
        }
        if (firstIndexUpper == -1)
        {
            firstIndex = firstIndexLower;
        }
        if (firstIndex == -1)
        {
            firstIndex = Mathf.Max(firstIndexLower, firstIndexUpper);
        }
        if (firstIndex == -1)
        {
            Debug.LogWarning("찾는 문자열이 없음");
            return originalText;
        }
        convertText =convertText.Remove(firstIndex,1);
        convertText = convertText.Insert(firstIndex, $"<size={fontSize}><color=#{ColorUtility.ToHtmlStringRGB(highlightColor)}>{highlightChar.ToUpper()}</color></size>");

        return convertText;
    }

 

 

 

찾아낸 첫번째 글자를 기준으로 분할함

        public static string[] SplitFirstIndex(string text, string separator)
        {

            var splitTextList = new List<string>();
            var firstIndexLower = text.IndexOf(separator.ToLower());
            var firstIndexUpper = text.IndexOf(separator.ToUpper());

            int firstIndex = -1;
            if (firstIndexLower == -1)
            {
                firstIndex = firstIndexUpper;
            }
            if (firstIndexUpper == -1)
            {
                firstIndex = firstIndexLower;
            }
            if (firstIndex == -1)
            {
                firstIndex = Mathf.Max(firstIndexLower, firstIndexUpper);
            }
            if (firstIndex == -1)
            {
                Debug.LogWarning("찾는 문자열이 없음");
                return null;
            }

            if (firstIndex == 0)
            {
                splitTextList.Add("");
            }
            else
            {
                splitTextList.Add(text.Substring(0, firstIndex));
            }
            
            if (firstIndex == text.Length)
            {
                splitTextList.Add("");
            }
            else
            {
                splitTextList.Add(text.Substring(firstIndex , text.Length-(firstIndex)));
            }

            return splitTextList.ToArray();
        }

 

 

대소문자구분없이 리플레이스

 

    public static string RelaceUL(string text,string oldValue, string newValue)
    {
        if (string.IsNullOrEmpty(oldValue))
        {
            return text;
        }
        var charList = text.ToCharArray().ToList();
        {
            int i = 0;
            while (i+ oldValue.Length-1 < charList.Count)
            {
                bool replaceCheck = true;
                for (int j = 0; j < oldValue.Length; j++)
                {
                    var word = charList[i + j].ToString();
                    if (System.Text.RegularExpressions.Regex.IsMatch(word, @"^[a-zA-Z]+$"))
                    {
                        var oldWord = oldValue[j].ToString();
                        if (word.ToUpper() != oldWord.ToUpper())
                        {
                            replaceCheck = false;
                            break;
                        }
                    }
                    else if (charList[i + j] != oldValue[j])
                    {
                        replaceCheck = false;
                        break;
                    }
                }

                if (replaceCheck)
                {
                    charList.RemoveRange(i, oldValue.Length);
                    charList.InsertRange(i, newValue.ToCharArray());
                    i += newValue.Length;
                }
                else
                {
                    i++;
                }
            }
        }
        return new string(charList.ToArray());

    }
    
    //Debug.Log(RelaceUL("1text 2Text 3TEXT 4텍스트 5text","text","convert"));
    //1convert 2convert 3convert 4텍스트 5convert

 

한국어 처리관련

Debug.Log((char)('가' + 1)); //각
Debug.Log((char)('가' + 2)); //갂
Debug.Log((char)('가' + 3)); //갃
Debug.Log((char)('나' + ('나' - '가'))); //따

 

 

Char To Hex

Debug.Log(((int)'가').ToString("X")); //AC00
Debug.Log(((int)'나').ToString("X")); //B098
Debug.Log(((int)'다').ToString("X")); //B2E4
Debug.Log(System.String.Format("{0:X}", (int)'가')); //AC00
Debug.Log(System.String.Format("{0:X}", (int)'나')); //B098
Debug.Log(System.String.Format("{0:X}", (int)'다')); //B2E4

 

String To HexString 간략버전

//String To HexString
string text = "테스트";
var bytes = System.Text.Encoding.UTF8.GetBytes(text);
var hexString = System.BitConverter.ToString(bytes);
Debug.Log(text);
Debug.Log(string.Join(",", bytes));
Debug.Log(hexString);


//HexString To String
var bytes2 = System.Array.ConvertAll(hexString.Split('-'), x => System.Convert.ToByte(x, 16));
var text2 = System.Text.Encoding.UTF8.GetString(bytes2);
Debug.Log(string.Join(",", bytes2));
Debug.Log(text2);

 

 

 

 

String To HexString 경량버전

//String To HexString2
string text = "테스트";
var bytes = System.Text.Encoding.UTF8.GetBytes(text);
var hexString = System.BitConverter.ToString(bytes).Replace("-","");
Debug.Log(text);
Debug.Log(string.Join(",", bytes));
Debug.Log(hexString);


//HexString To String2
var bytes2 = new byte[hexString.Length / 2];
for (int i = 0; i < bytes2.Length; i++)
{
	bytes2[i] = System.Convert.ToByte(hexString.Substring(i * 2, 2), 16);
}
var text2 = System.Text.Encoding.UTF8.GetString(bytes2);
Debug.Log(string.Join(",", bytes2));
Debug.Log(text2);

 

 

 

Bytes To HexString V1

//bytes To HexString
{
    System.Text.StringBuilder sb = new System.Text.StringBuilder();
    foreach (byte b in bytes)
    {
        sb.Append(b.ToString("X2"));
    }
    string hexString = sb.ToString();
}

 

Bytes To HexString V2

string hexString = System.BitConverter.ToString(bytes).Replace("-", "");

 

 

 

 

UTF8 to ASCII

옛날시스템과 호환시킬때 사용한다

ASCII는 7비트니까 UTF7으로 변환시킨후 아스키로 바꿔서 전송

//UTF8 to ASCII
string text = "테스트";
var bytes = System.Text.Encoding.UTF7.GetBytes(text);
var ascii = System.Text.Encoding.ASCII.GetString(bytes);
Debug.Log(text);
Debug.Log(string.Join(",", bytes));
Debug.Log(ascii);


//ASCII to UTF8
var bytes2 = System.Text.Encoding.ASCII.GetBytes(ascii);
var text2 = System.Text.Encoding.UTF7.GetString(bytes2);
Debug.Log(string.Join(",", bytes2));
Debug.Log(text2);

 

 

 

String To Bytes

//문자열 -> 바이트배열
System.Text.Encoding.Default.GetBytes(text);

//바이트배열 -> 문자열 
System.Text.Encoding.Default.GetString(bytes2)

 

 

 

 

 

 

Second To String

//0:02:13.878
System.TimeSpan.FromSeconds(clip.length).ToString("g")

 

 

비슷한 문장 검색

클래스형이 아니라 string으로 바꿔놔야 쓰기 편할텐데 나중에하자

MemorizationData GetSimilarWord(MemorizationData fromWord, List<MemorizationData> words)
{
    var similarWords = GetSimilarWords(fromWord, words);
    if (similarWords.Count == 0)
    {
        return null;
    }

    //셔플
    similarWords = similarWords.OrderBy(a => Random.value).ToList();


    return similarWords[0];
}
List<MemorizationData> GetSimilarWords(MemorizationData fromWord, List<MemorizationData> words)
{


    //중복이 아닌 단어들만 가져옴
    var filteredWords = words.FindAll(x => x.question != fromWord.question);
    if (filteredWords.Count == 0)
    {
        return null;
    }


    var similarWords = new List<MemorizationData>();
    for (int n = 2; n > 0; n--) //2글자까지만 검색
    {
        //n글자 이상 중복
        similarWords.AddRange(filteredWords.FindAll(word =>
        {
            if (word.question.Length < n)
            {
                return false;
            }
            for (int i = 0; i <= fromWord.question.Length-n; i++)
            {

                var fromWordSub= fromWord.question.Substring(i, n);
                if (fromWordSub.Length==1)
                {
                    if (fromWordSub[0] >= 0x20000 && fromWordSub[0] <= 0xFA2D)
                    {
                        //이것은 한자임
                    }
                    else
                    {
                        return false; //단일문자인데 한자가 아니라서 스킵
                    }
                }
                if (word.question.Contains(fromWord.question.Substring(i, n)))
                {
                    return true;
                }
            }
            return false;
        }));

        if (similarWords.Count > 0)
        {
            return similarWords;
        }
    }
    /*
    if (similarWords.Count == 0)
    {
        return null;
    }
    */
    return similarWords;
}