unisbadri.com » Python Java Golang Typescript Kotlin Ruby Rust Dart PHP
Regex

Regex #

Regular expressions (regex) dalam bahasa pemrograman Golang digunakan untuk pencocokan pola dan manipulasi string. Paket regexp menyediakan berbagai fungsi untuk bekerja dengan regex. Berikut adalah penjelasan tentang regex di Golang dan berbagai operasi yang dapat dilakukan:

Mengimpor Paket regexp #

Untuk menggunakan regex di Golang, Anda harus mengimpor paket regexp.

import "regexp"

Membuat Regex #

Anda dapat membuat objek regex dengan menggunakan fungsi regexp.Compile atau regexp.MustCompile.

re, err := regexp.Compile("a+b")
if err != nil {
    fmt.Println(err)
}

re := regexp.MustCompile("a+b") // Panics if the regex is invalid

Pencocokan String dengan Regex #

Fungsi MatchString digunakan untuk memeriksa apakah suatu string cocok dengan pola regex.

matched := re.MatchString("aaab")
fmt.Println(matched) // Output: true

Mencari String yang Cocok #

Fungsi FindString digunakan untuk mencari substring pertama yang cocok dengan pola regex.

result := re.FindString("aaab aab ab")
fmt.Println(result) // Output: aaab

Mencari Semua String yang Cocok #

Fungsi FindAllString digunakan untuk mencari semua substring yang cocok dengan pola regex.

results := re.FindAllString("aaab aab ab", -1)
fmt.Println(results) // Output: [aaab aab]

Mencari Indeks String yang Cocok #

Fungsi FindStringIndex digunakan untuk mendapatkan indeks dari substring yang cocok.

indices := re.FindStringIndex("aaab aab ab")
fmt.Println(indices) // Output: [0 4]

Mencari Semua Indeks String yang Cocok #

Fungsi FindAllStringIndex digunakan untuk mendapatkan indeks dari semua substring yang cocok.

allIndices := re.FindAllStringIndex("aaab aab ab", -1)
fmt.Println(allIndices) // Output: [[0 4] [5 8]]

Menangkap Grup dalam Regex #

Fungsi FindStringSubmatch digunakan untuk menangkap grup dalam regex.

re = regexp.MustCompile(`a(b+)`)
result := re.FindStringSubmatch("aaab")
fmt.Println(result) // Output: [aaab bbb]

Mengganti Substring dengan Regex #

Fungsi ReplaceAllString digunakan untuk mengganti substring yang cocok dengan pola regex.

re = regexp.MustCompile("a+")
replaced := re.ReplaceAllString("aaab aab ab", "X")
fmt.Println(replaced) // Output: Xb Xb b

Contoh Lengkap Penggunaan Regex # 

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // Membuat regex
    re := regexp.MustCompile("a+b")

    // Pencocokan string dengan regex
    matched := re.MatchString("aaab")
    fmt.Println("Matched:", matched) // Output: Matched: true

    // Mencari string yang cocok
    result := re.FindString("aaab aab ab")
    fmt.Println("First match:", result) // Output: First match: aaab

    // Mencari semua string yang cocok
    results := re.FindAllString("aaab aab ab", -1)
    fmt.Println("All matches:", results) // Output: All matches: [aaab aab]

    // Mencari indeks string yang cocok
    indices := re.FindStringIndex("aaab aab ab")
    fmt.Println("First match indices:", indices) // Output: First match indices: [0 4]

    // Mencari semua indeks string yang cocok
    allIndices := re.FindAllStringIndex("aaab aab ab", -1)
    fmt.Println("All match indices:", allIndices) // Output: All match indices: [[0 4] [5 8]]

    // Menangkap grup dalam regex
    re = regexp.MustCompile(`a(b+)`)
    submatch := re.FindStringSubmatch("aaab")
    fmt.Println("Submatch:", submatch) // Output: [aaab bbb]

    // Mengganti substring dengan regex
    re = regexp.MustCompile("a+")
    replaced := re.ReplaceAllString("aaab aab ab", "X")
    fmt.Println("Replaced string:", replaced) // Output: Xb Xb b
}

Menggunakan Flags dalam Regex #

Anda dapat menambahkan flag pada regex untuk mengubah perilaku pencocokan, seperti pencocokan case-insensitive.

re = regexp.MustCompile(`(?i)a+b`) // (?i) membuat pencocokan case-insensitive
matched = re.MatchString("AaB")
fmt.Println("Case-insensitive match:", matched) // Output: true

Berikut adalah penjelasan tentang berbagai identifier regex di Golang, diikuti dengan contoh penggunaannya dalam section yang terpisah.

Penjelasan Identifier Regex di Golang #

Identifier Deskripsi Contoh Regex Contoh String yang Cocok Penjelasan
. Karakter apa saja kecuali newline a.b aab, acb Cocok dengan a diikuti oleh karakter apa saja dan b
^ Awal dari string ^a apple Cocok dengan string yang dimulai dengan a
$ Akhir dari string a$ casa Cocok dengan string yang diakhiri dengan a
* 0 atau lebih pengulangan karakter sebelumnya ab*c ac, abc, abbc Cocok dengan a diikuti oleh 0 atau lebih b dan kemudian c
+ 1 atau lebih pengulangan karakter sebelumnya ab+c abc, abbc Cocok dengan a diikuti oleh 1 atau lebih b dan kemudian c
? 0 atau 1 pengulangan karakter sebelumnya ab?c ac, abc Cocok dengan a diikuti oleh 0 atau 1 b dan kemudian c
\d Karakter digit \d 1, 9, 0 Cocok dengan karakter digit (0-9)
\D Karakter bukan digit \D a, %, Z Cocok dengan karakter bukan digit
\w Karakter kata (alfanumerik + underscore) \w a, 5, _ Cocok dengan karakter kata (alfabet, digit, atau underscore)
\W Karakter bukan kata \W %, #, Cocok dengan karakter bukan kata (bukan alfabet, digit, atau underscore)
\s Karakter spasi putih \s , \t, \n Cocok dengan karakter spasi putih (space, tab, newline)
\S Karakter bukan spasi putih \S a, 1, % Cocok dengan karakter bukan spasi putih
[] Karakter dalam set [abc] a, b, c Cocok dengan salah satu karakter dalam set [abc]
[^] Karakter bukan dalam set [^abc] d, 1, % Cocok dengan karakter yang bukan dalam set [abc]
() Grup (abc) abc Grup karakter sebagai satu kesatuan
Atau (alternatif) `a b`
{n} Tepat n pengulangan karakter sebelumnya a{2} aa Cocok dengan tepat 2 a berturut-turut
{n,} n atau lebih pengulangan karakter sebelumnya a{2,} aa, aaa, aaaa Cocok dengan 2 atau lebih a berturut-turut
{n,m} Antara n dan m pengulangan karakter sebelumnya a{2,4} aa, aaa, aaaa Cocok dengan antara 2 dan 4 a berturut-turut
\b Batas kata \bword\b word (standalone) Cocok dengan batas kata di sekeliling word
\B Bukan batas kata \Bword\B Swordsmanship Cocok dengan word di tengah kata
(?i) Case insensitive (?i)abc abc, Abc, ABC Cocok dengan abc tanpa memperhatikan huruf besar/kecil

Contoh Implementasi Regex di Golang #

Berikut adalah contoh penggunaan beberapa identifier regex di Golang:

package main

import (
    "fmt"
    "regexp"
)

func main() {
    // Contoh penggunaan '.'
    re := regexp.MustCompile("a.b")
    fmt.Println(re.MatchString("acb")) // Output: true

    // Contoh penggunaan '^' dan '$'
    re = regexp.MustCompile("^a.*b$")
    fmt.Println(re.MatchString("apple"))   // Output: false
    fmt.Println(re.MatchString("ab"))      // Output: true
    fmt.Println(re.MatchString("aab"))     // Output: true

    // Contoh penggunaan '\d' dan '\D'
    re = regexp.MustCompile(`\d+`)
    fmt.Println(re.FindString("abc123xyz")) // Output: 123

    // Contoh penggunaan '\w' dan '\W'
    re = regexp.MustCompile(`\w+`)
    fmt.Println(re.FindString("hello world!")) // Output: hello

    // Contoh penggunaan '[]' dan '[^]'
    re = regexp.MustCompile(`[aeiou]`)
    fmt.Println(re.FindAllString("hello world", -1)) // Output: [e o o]

    re = regexp.MustCompile(`[^aeiou]`)
    fmt.Println(re.FindAllString("hello world", -1)) // Output: [h l l w r l d]

    // Contoh penggunaan '{n}', '{n,}', dan '{n,m}'
    re = regexp.MustCompile(`a{2,4}`)
    fmt.Println(re.FindString("caaaandy")) // Output: aaaa

    // Contoh penggunaan '\b' dan '\B'
    re = regexp.MustCompile(`\bword\b`)
    fmt.Println(re.MatchString("word")) // Output: true
    fmt.Println(re.MatchString("Swordsmanship")) // Output: false

    re = regexp.MustCompile(`\Bword\B`)
    fmt.Println(re.MatchString("Swordsmanship")) // Output: true

    // Contoh penggunaan '(?i)' untuk case insensitive
    re = regexp.MustCompile(`(?i)abc`)
    fmt.Println(re.MatchString("ABC")) // Output: true
}

Tabel penjelasan di atas memberikan deskripsi singkat tentang setiap identifier regex, sementara section contoh menunjukkan bagaimana setiap identifier dapat digunakan dalam kode Golang.

Kesimpulan #

Dengan menggunakan regex, Anda dapat melakukan berbagai operasi pencocokan pola dan manipulasi string dengan cara yang efisien dan powerful di Golang. Regex sangat berguna untuk tugas-tugas seperti validasi input, pencarian teks, dan penggantian teks.

« Date Time
Vendor »