Ανάλυση αρχείων καταγραφής

Το πακέτο regexp προσφέρει υποστήριξη για κανονικές εκφράσεις στη Go.

Σύνταξη

Η σύνταξη των κανονικών εκφράσεων που γίνονται δεκτές είναι η ίδια γενική σύνταξη που χρησιμοποιείται από τη Perl, την Python και άλλες γλώσσες.

Τόσο τα μοτίβα αναζήτησης όσο και τα κείμενα εισόδου ερμηνεύονται ως UTF-8.

Όταν χρησιμοποιείς backticks (βαρείες) για να φτιάξεις συμβολοσειρές, οι κάθετοι () to make strings, backslashes () δεν έχουν κανένα ειδικό νόημα και δεν σηματοδοτούν την αρχή ειδικών χαρακτήρων όπως το tab ) don't have any special meaning and don't mark the beginning of special characters like tabs ή η αλλαγή γραμμής or newlines:

"\t\n" // regular string literal with 2 characters: a tab and a newline
`\t\n`// raw string literal with 4 characters: two backslashes, a 't', and an 'n'

Γι' αυτόν τον λόγο, είναι προτιμότερο να χρησιμοποιείς backticks για να φτιάχνεις κανονικές εκφράσεις, γιατί έτσι δεν χρειάζεται να κάνεις escape τις κάθετους:

"\\" // string with a single backslash
`\\` // string with 2 backslashes

Μεταγλώττιση μοτίβων - τύπος RegExp

Για να χρησιμοποιήσεις μια κανονική έκφραση, πρέπει πρώτα να μεταγλωττίσεις το μοτίβο της συμβολοσειράς. Η μεταγλώττιση εδώ σημαίνει ότι παίρνεις το μοτίβο συμβολοσειράς της κανονικής έκφρασης και το μετατρέπεις σε μια εσωτερική αναπαράσταση που είναι πιο εύκολο να τη χειριστείς. Χρειάζεται να μεταγλωττίσεις κάθε μοτίβο μόνο μία φορά, κι έπειτα μπορείς να χρησιμοποιήσεις τη μεταγλωττισμένη εκδοχή της κανονικής έκφρασης πολλές φορές. Ο τύπος regexp.Regexp αναπαριστά μια μεταγλωττισμένη κανονική έκφραση. Μπορείς να μεταγλωττίσεις ένα μοτίβο συμβολοσειράς σε regexp.Regexp χρησιμοποιώντας τη συνάρτηση regexp.Compile. Αυτή η συνάρτηση επιστρέφει nil και ένα σφάλμα αν η μεταγλώττιση απέτυχε:

re, err := regexp.Compile(`(a|b)+`)
fmt.Println(re, err) // => (a|b)+ <nil>
re, err = regexp.Compile(`a|b)+`)
fmt.Println(re, err) // => <nil> error parsing regexp: unexpected ): `a|b)+`

Η συνάρτηση MustCompile είναι ένας βολικός εναλλακτικός τρόπος αντί για τη Compile:

re = regexp.MustCompile(`[a-z]+\d*`)

Χρησιμοποιώντας αυτή τη συνάρτηση, δεν χρειάζεται να χειριστείς κάποιο σφάλμα.

Μέθοδοι κανονικών εκφράσεων

Υπάρχουν 16 μέθοδοι του Regexp που αντιστοιχίζουν μια κανονική έκφραση και εντοπίζουν το κείμενο που αντιστοιχίστηκε. Τα ονόματά τους αντιστοιχίζονται από αυτή την κανονική έκφραση:

Find(All)?(String)?(Submatch)?(Index)?

• Αν υπάρχει το All, η μέθοδος αντιστοιχίζει διαδοχικές μη επικαλυπτόμενες αντιστοιχίσεις ολόκληρης της έκφρασης.
• Αν υπάρχει το String, το όρισμα είναι συμβολοσειρά, αλλιώς είναι ένα τμήμα byte· οι τιμές επιστροφής προσαρμόζονται ανάλογα.
• Αν υπάρχει το Submatch, η τιμή επιστροφής είναι ένα τμήμα που προσδιορίζει τις διαδοχικές υπο-αντιστοιχίσεις της έκφρασης.
• Αν υπάρχει το Index, οι αντιστοιχίσεις και οι υπο-αντιστοιχίσεις προσδιορίζονται από ζεύγη θέσεων byte μέσα στη συμβολοσειρά εισόδου.

Υπάρχουν επίσης μέθοδοι για:

• την αντικατάσταση αντιστοιχίσεων κανονικών εκφράσεων με συμβολοσειρές αντικατάστασης και
• τον τεμαχισμό συμβολοσειρών που χωρίζονται από κανονικές εκφράσεις.

Συνολικά, το πακέτο regexp ορίζει περισσότερες από 40 συναρτήσεις και μεθόδους. Παρακάτω θα δεις τη χρήση μερικών μεθόδων. Δες την τεκμηρίωση API για λεπτομέρειες σχετικά με αυτές τις συναρτήσεις και άλλες.

Παραδείγματα MatchString

Η μέθοδος MatchString αναφέρει αν μια συμβολοσειρά περιέχει οποιαδήποτε αντιστοίχιση μιας κανονικής έκφρασης.

re = regexp.MustCompile(`[a-z]+\d*`)
b = re.MatchString("[a12]")       // => true
b = re.MatchString("12abc34(ef)") // => true
b = re.MatchString(" abc!")       // => true
b = re.MatchString("123 456")     // => false

Παραδείγματα FindString

Η μέθοδος FindString επιστρέφει μια συμβολοσειρά που περιέχει το κείμενο της πιο αριστερής αντιστοίχισης της κανονικής έκφρασης.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.FindString("[a12]")       // => "a12"
s = re.FindString("12abc34(ef)") // => "abc34"
s = re.FindString(" abc!")       // => "abc"
s = re.FindString("123 456")     // => ""

Παραδείγματα FindStringSubmatch

Η μέθοδος FindStringSubmatch επιστρέφει ένα τμήμα συμβολοσειρών που περιέχει το κείμενο της πιο αριστερής αντιστοίχισης της κανονικής έκφρασης και τις αντιστοιχίσεις, αν υπάρχουν, των υποεκφράσεών της. Αυτό μπορεί να χρησιμοποιηθεί για να προσδιορίσεις τις συμβολοσειρές που ταιριάζουν με ομάδες σύλληψης. Μια τιμή επιστροφής nil δηλώνει ότι δεν υπάρχει αντιστοίχιση.

re = regexp.MustCompile(`[a-z]+(\d*)`)
sl = re.FindStringSubmatch("[a12]")       // => []string{"a12","12"}
sl = re.FindStringSubmatch("12abc34(ef)") // => []string{"abc34","34"}
sl = re.FindStringSubmatch(" abc!")       // => []string{"abc",""}
sl = re.FindStringSubmatch("123 456")     // => <nil>

Παραδείγματα ReplaceAllString

Η μέθοδος re.ReplaceAllString(src,repl) επιστρέφει ένα αντίγραφο του src, αντικαθιστώντας τις αντιστοιχίσεις της κανονικής έκφρασης re με τη συμβολοσειρά αντικατάστασης repl.

re = regexp.MustCompile(`[a-z]+\d*`)
s = re.ReplaceAllString("[a12]", "X")       // => "[X]"
s = re.ReplaceAllString("12abc34(ef)", "X") // => "12X(X)"
s = re.ReplaceAllString(" abc!", "X")       // => " X!"
s = re.ReplaceAllString("123 456", "X")     // => "123 456"

Παραδείγματα Split

Η μέθοδος re.Split(s,n) τεμαχίζει ένα κείμενο s σε υποσυμβολοσειρές που χωρίζονται από την έκφραση και επιστρέφει ένα τμήμα με τις υποσυμβολοσειρές που βρίσκονται ανάμεσα σε αυτές τις αντιστοιχίσεις της έκφρασης. Το πλήθος n καθορίζει τον μέγιστο αριθμό υποσυμβολοσειρών που θα επιστραφούν. Αν n<0, η μέθοδος επιστρέφει όλες τις υποσυμβολοσειρές.

re = regexp.MustCompile(`[a-z]+\d*`)
sl = re.Split("[a12]", -1)      // => []string{"[","]"}
sl = re.Split("12abc34(ef)", 2) // => []string{"12","(ef)"}
sl = re.Split(" abc!", -1)      // => []string{" ","!"}
sl = re.Split("123 456", -1)    // => []string{"123 456"}