Go언어의 출력함수 IO, 문자열 처리 및 조작, 정규식 2장

◆ String 패키지의 문자열 검색을 위한 함수

▶ func Contains(s, substr string) bool: 문자열이 포함되어 있는지 검색

▶ func ContainsAny(s, chars string) bool: 특정 문자가 하나라도 포함되어 있는지 검색

▶ func ContainsRune(s string, r rune) bool: rune 자료형으로 검색

▶ func Count(s, sep string) int: 문자열이 몇 번 나오는지 구함

▶ func HasPrefix(s, prefix string) bool: 문자열이 접두사인지 판단

▶ func HasSuffix(s, suffix string) bool: 문자열이 접미사인지 판단

▶ func lndex(s, sep string) int: 특정 문자열의 위치를 구함

▶ func lndexAny(s, chars string) int: 가장 먼저 나오는 문자의 위치를 구함

▶ func lndexByte(s string, c byte) int: byte 자료형으로 위치를 구함

▶ func lndexRune(s string, r rune) int: rune 자료형으로 위치를 구함

▶ func lndexFunc(s string, f func(rune) bool) int: 검색 함수를 정의하여 위치를 구함

▶ func Lastlndex(s, sep string) int: 가장 마지막에 나오는 특정 문자열의 위치를 구함

▶ func LastlndexAny(s, 아iars string) int: 가장 마지막에 나오는 문자의 위치를 구함

▶ func LastlndexFunc(s string, f func(rune) bool) int: 검색 함수를 정의하여 위치를 구함

 

● 문자열 검색

package main

import (
  "fmt"
  "strings"
  "unicode"
)

func main() {
  fmt.Println(strings.Index("Hello, world!", "He"))  // 0: He가 맨 처음에 있으므로 0
  fmt.Println(strings.Index("Hello, world!", "wor")) // 7: wor가 8번째에 있으므로 7
  fmt.Println(strings.Index("Hello, world!", "ow"))  // -1: ow는 없으므로 -1

  fmt.Println(strings.IndexAny("Hello, world!", "eo")) // 1: e가 2번째에 있으므로 1
  fmt.Println(strings.IndexAny("Hello, world!", "f"))  // -1: f는 없으므로 -1

  var c byte
  c = 'd'
  fmt.Println(strings.IndexByte("Hello, world!", c)) // 11: d가 12번째에 있으므로 11
  c = 'f'
  fmt.Println(strings.IndexByte("Hello, world!", c)) // -1: f는 없으므로 -1

  var r rune
  r = '언'
  fmt.Println(strings.IndexRune("고 언어", r)) // 4: "언"이 시작되는 인덱스가 4

  f := func(r rune) bool {
  return unicode.Is(unicode.Hangul, r) // r이 한글 유니코드이면 true를 리턴
  }

  fmt.Println(strings.IndexFunc("Go 언어", f))  // 3: 한글이 4번째부터 시작하므로 3
  fmt.Println(strings.IndexFunc("Go Language", f)) // -1: 한글이 없으므로 -1

  fmt.Println(strings.LastIndex("Hello Hello Hello, world!", "Hello"))
                                                                // 12: 마지막 Hello가 13번째에 있으므로 12

  fmt.Println(strings.LastIndexAny("Hello, world", "ol")) // 10: 마지막 l이 11번째에 있으므로 10

  fmt.Println(strings.LastIndexFunc("Go 언어 안녕", f)) // 13: 마지막 한글인 '녕'이 시작되는 인덱스가 13
}

◆ String 패키지의 문자열 조작을 위한 함수

▶ func Join(a []string, sep string) string: 문자열 슬라이스에 저장된 문자열을 모두 연결

▶ func Split(s, sep string) []string: 지정된 문자열을 기준으로 문자열을 쪼개주는 함수

▶ func Fi이ds(s string) []string: 공백을 기존으로 문자열을 쪼개어 문자열 슬라이스로 저장

▶ func FieldsFunc(s string, f func(rune) bool) []string: 유니코드 검사 함수를 정의한 뒤 특정 유니코드 값을 기준으로 문자열을 쪼개어 문자열 슬라이스로 저장

▶ func Repeat(s string, count int) string: 문자열을 특정 횟수만큼 반복

▶ func Replace(s, old, new string, n int) string: 문자열에서 특정 문자열을 바꿈

▶ func Trim(s string, cutset string) string:문자열 앞 뒤에 있는 특정 문자열 제거

▶ func TrimLeft(s string, cutset string) string: 문자열 앞에 오는 특정 문자열 제거

▶ func TrimRight(s string, cutset string) string: 문자열 뒤에 오는 특정 문자열 제거

▶ func TrimFunc(s string, f func(rune) bool) string: 문자열 정리 함수를 정의하여 문자열 제거

▶ func TrimLeftFunc(s string, f func(rune) bool) string: 문자열 앞에 오는 특정 문자열 제거

▶ func TrimRightFunc(s string, f func(rune) bool) string: 문자열 뒤에 오는 특정 문자열 제거

▶ func TrimSpace(s string) string: 문자열 앞뒤에 오는 공백 문자 제거

▶ func TrimSuffix(s, suffix string) string: 접미사 제거

▶ func NewReplacer(이dnew ...string) *Replacer: 문자열 교체 인스턴스를 생성

▶ func (r *Replacer) Replace(s string) string: 문자열 교체 인스턴스를 사용하여 문자열을 교체

 

● 문자열 조작

package main

import (
  "fmt"
  "strings"
  "unicode"
)

func main() {
  s1 := []string{"Hello,", "world!"}
  fmt.Println(strings.Join(s1, " ")) // Hello, world!
  s2 := strings.Split("Hello, world!", " ")
  fmt.Println(s2[1]) // world!
  s3 := strings.Fields("Hello, world!")
  fmt.Println(s3[1]) // world!

  f := func(r rune) bool {
  return unicode.Is(unicode.Hangul, r) // r이 한글 유니코드이면 true를 리턴
  }

  s4 := strings.FieldsFunc("Hello안녕Hello", f)
  fmt.Println(s4) // [Hello Hello]
  fmt.Println(strings.Repeat("Hello", 2)) // HelloHello
  fmt.Println(strings.Replace("Hello, world!", "world", "Go", 1)) // Hello, Go!
  fmt.Println(strings.Replace("Hello Hello", "llo", "Go", 2))     // HeGo HeGo
}

---

◆ 문자열 변환 함수 - strconv 패키지

▶ func Atoi(s string) (i int, err error): 숫자로 이루어진 문자열을 숫자로 변환

▶ func ltoa(i int) string: 숫자를 문자열로 변환

▶ func FormatBool(b bool) string: 불 값을 문자열로 변환

▶ func FormatFloat(f float64, fmt byte, prec, bitSize int) string: 실수를 문자열로 변환

▶ func Formatlnt(i int64, base int) string: 부호 있는 정수를 문자열로 변환

▶ func Formatl)int(i uint64, base int) string: 부호 없는 정수를 문자열로 변환

▶ func AppendBool(dst []byte, b bool) []byte: 불 값을 문자열로 변환하여 슬라이스 뒤에 추가

▶ func AppendFloat(dst []byte, f float64, fmt byte, prec int, bitSize int) []byte: 실수를 문자열로 변환하여 슬라이스 뒤에 추가

▶ func Appendlnt(dst []byte, i int64, base int) []byte: 정수를 문자열로 변환하여 슬라이스 뒤에 추가

▶ func Appen에Jint(dst []byte, i uint64, base int) []byte: 정수를 문자열로 변환하여 슬라이스 뒤에 추가

▶ func ParseBool(str string) (wh」e bool, err error): 불 형태의 문자열을 불로 변환

▶ func ParseFloat(s string, bitSize int) (f float64, err error): 실수 형태의 문자열을 실수로 변환

▶ func Parselnt(s string, base int, bitSize int) (i int64, err error): 문자열을 부호 있는 정수로

▶ func Parsellint(s string, base int, bitSize int) (n uint64, err error): 문자열 을 부호 없는 정수로

 

● 문자열 변환

package main

import (
  "fmt"
  "strconv"
)

func main() {
  var err error
  var num1 int
  num1, err = strconv.Atoi("100") // 문자열 "100"을 숫자 100으로 변환
  fmt.Println(num1, err)          // 100 <nil>

  var num2 int
  num2, err = strconv.Atoi("10t") // 10t는 숫자가 아니므로 에러가 발생함
  fmt.Println(num2, err)          // 0 strconv.ParseInt: parsing "10t": invalid syntax

  var s string
  s = strconv.Itoa(50) // 숫자 50을 문자열 "50"으로 변환
  fmt.Println(s)       // 50
}

◆ 정규식

▶  regexp 패키지의 func MatchString(pattern string, s string) (matched bool, err error): 문자열이 정규 표현식에맞는지 검사

● 정규식 검사

package main

import (
  "fmt"
  "regexp"
)

func main() {
  matched, _ := regexp.MatchString("He", "Hello 100")
  fmt.Println(matched) // true: Hello 100에 He가 포함되므로 true

  matched, _ = regexp.MatchString("H.", "Hi")
  fmt.Println(matched) // true: H 뒤에 글자가 하나가 있으므로 true

  matched, _ = regexp.MatchString("[a-zA-Z0-9]+", "Hello 100")
  fmt.Println(matched) // true: Hello 100은 a부터 z까지, A부터 Z까지 0부터 9까지에 포함되므로 true

  matched, _ = regexp.MatchString("[a-zA-Z0-9]*", "")
  fmt.Println(matched) // true: *는 값이 하나도 안나와도 되므로 true

  matched, _ = regexp.MatchString("[0-9]+-[0-9]+", "1-1")
  fmt.Println(matched) // true: 1-1는 [0-9]+와 - 그리고 [0-9]+가 합쳐진 것이므로 true

  matched, _ = regexp.MatchString("[0-9]+-[0-9]+", "1-")
  fmt.Println(matched) // false: 1-는 [0-9]+와 -만 있으므로 false

  matched, _ = regexp.MatchString("[0-9]+/[0-9]*", "1/")
  fmt.Println(matched) // true: 1/는 [0-9]+와 /가 있음. *는 값이 없어도 되므로 true

  matched, _ = regexp.MatchString("[0-9]+\\+[0-9]*", "1+")
  fmt.Println(matched) // true: 1+는 [0-9]+와 +가 있음. *는 값이 없어도 되므로 true

  matched, _ = regexp.MatchString("[^A-Z]+", "hello")
  fmt.Println(matched) // true: hello는 A부터 Z까지에 포함되지 않으므로 true
}

● 정규식 한글 검사

package main

import (
  "fmt"
  "regexp"
)

func main() {
  matched, _ := regexp.MatchString("[가-힣]+", "안녕하세요")
  fmt.Println(matched) // true

  matched, _ = regexp.MatchString("홍[가-힣]+동", "홍길동")
  fmt.Println(matched) // true

  matched, _ = regexp.MatchString("이재[홍-훈]", "이재홍")
  fmt.Println(matched) // true
}

● 정규식을 문자열 조작

package main

import (
  "fmt"
  "regexp"
)

func main() {
  re1, _ := regexp.Compile("\\.[a-zA-Z]+$")
  s1 := re1.ReplaceAllString("hello example.com", ".net")
                        // 정규표현식에 해당하는 문자열을 지정된 문자열로 바꿈
  fmt.Println(s1) // hello example.net: 맨 마지막에 오는 ".영문"을 .net으로 바꿈

  re2, _ := regexp.Compile("([a-zA-Z,]+) ([a-zA-Z!]+)")
  s2 := re2.ReplaceAllString("Hello, world!", "${2}")

                        // 정규표현식에 해당하는 문자열을 지정된 문자열로 바꿈
  fmt.Println(s2) // world!: ${2}만 있으므로 두 번째로 찾은 문자열 world!만 남김

  re3, _ := regexp.Compile("([a-zA-Z,]+) ([a-zA-Z!]+)")
  s3 := re3.ReplaceAllString("Hello, world!", "${2} ${1}")
                        // 정규표현식에 해당하는 문자열을 지정된 문자열로 바꿈
  fmt.Println(s3) // world! Hello,: ${2} ${1}로 설정했으므로 두 문자열의 위치를 바꿈

  re4, _ := regexp.Compile("(?P<first>[a-zA-Z,]+) (?P<second>[a-zA-Z!]+)")
                        // 찾은 문자열에 ${first}, ${second}로 이름을 정함
  s4 := re4.ReplaceAllString("Hello, world!", "${second} ${first}")
                        // 정규표현식에 해당하는 문자열을 지정된 문자열로 바꿈

  fmt.Println(s4) // world! Hello,: ${second} ${first}로 설정했으므로
                        // 두 문자열의 위치를 바꿈

  re5, _ := regexp.Compile("(?P<first>[a-zA-Z,]+) (?P<second>[a-zA-Z!]+)")
  s5 := re5.ReplaceAllLiteralString("Hello, world!", "${second} ${first}")
                        // 문자열을 바꿀 때 정규표현식 기호를 무시함
  fmt.Println(s5) // ${second} ${first}: 정규표현식 기호를 무시했으므로
                        // ${second} ${first}가 그대로 표시됨
}