Jak zrobić wyrażenie regularne bez rozróżniania wielkości liter w Go?

Teraz, oczywiście, mógłbym napisać moje wyrażenie regularne, aby obsłużyć oba przypadki, na przykład regexp.Compile("[a-zA-Z]"), ale moje wyrażenie regularne jest zbudowane z ciągu podanego przez użytkownika:

reg, err := regexp.Compile(strings.Replace(s.Name, " ", "[ \\._-]", -1))

Gdzie s.Namejest nazwa. Może to być coś w rodzaju „North by Northwest”. Teraz najbardziej oczywistym rozwiązaniem byłoby dla mnie przejście przez każdy znak s.Namei napisanie „[nN]” dla każdej litery:

for i := 0; i < len(s.Name); i++ {
  if s.Name[i] == " " {
    fmt.Fprintf(str, "%s[ \\._-]", str);
  } else {
    fmt.Fprintf(str, "%s[%s%s]", str, strings.ToLower(s.Name[i]), strings.ToUpper(s.Name[i]))
  }
}

Ale wydaje mi się, że to raczej mało eleganckie rozwiązanie. Szybkość nie jest tak naprawdę problemem, ale muszę wiedzieć, czy jest inny sposób.

Możesz ustawić flagę bez rozróżniania wielkości liter jako pierwszy element w wyrażeniu regularnym.

Robisz to, dodając "(?i)"na początku wyrażenia regularnego.

reg, err := regexp.Compile("(?i)"+strings.Replace(s.Name, " ", "[ \\._-]", -1))

W przypadku stałego wyrażenia regularnego wyglądałoby to tak.

r := regexp.MustCompile(`(?i)CaSe`)

Aby uzyskać więcej informacji o flagach, poszukaj w regexp/syntaxdokumentacji pakietu (lub dokumentacji składni ) terminu „flagi”.

Możesz dodać (?i)na początku wzoru, aby wielkość liter nie była rozróżniana.

Odniesienie

Nie znam go zbyt dobrze, ale zgodnie z tym przykładem: http://play.golang.org/p/WgpNhwWWuW

Musisz poprzedzić wyrażenie regularne ciągiem (?i)

Użyj iflagi. Cytując dokumentację porad :

Grupowanie:

(re)           numbered capturing group
(?P<name>re)   named & numbered capturing group
(?:re)         non-capturing group
(?flags)       set flags within current group; non-capturing
(?flags:re)    set flags during re; non-capturing

Składnia flagi to xyz (zestaw) lub -xyz (wyczyść) lub xy-z (zestaw xy, wyczyść z). Flagi to:

i              case-insensitive (default false)
m              multi-line mode: ^ and $ match begin/end line in addition to begin/end text (default false)
s              let . match \n (default false)
U              ungreedy: swap meaning of x* and x*?, x+ and x+?, etc (default false)