0Pricing
Go Academy · บทเรียน

การแทนที่ข้อความ

รูปแบบ ReplaceAll

การแทนที่ข้อความ เป็นบทเรียน Go Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Go Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

การแทนที่ตามรูปแบบ

นิพจน์ปกติใช้เขียนข้อความใหม่ได้ ไม่ได้มีไว้แค่ค้นหาเท่านั้น ReplaceAllString จะแทนที่การจับคู่ทุกแห่งด้วยสตริงทดแทน

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.ReplaceAllString("a1b2c3", "#"))
}

การแทนที่คำทั้งคำ

รูปแบบอย่าง cat|dog ช่วยให้คุณแทนที่ทางเลือกหลายแบบได้ในครั้งเดียว

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("cat|dog")
    fmt.Println(re.ReplaceAllString("my cat and dog", "pet"))
}

การยุบช่องว่าง

การทำความสะอาดข้อความที่พบบ่อยคือ แทนที่ชุดช่องว่างต่อเนื่องด้วยช่องว่างหนึ่งช่องโดยใช้ \s+

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("\\s+")
    fmt.Println(re.ReplaceAllString("too   many    spaces", " "))
}

การอ้างอิงกลุ่ม

ในข้อความทดแทน $1 จะแทรกกลุ่มจับกลุ่มแรก และ $2 จะแทรกกลุ่มจับกลุ่มที่สอง วิธีนี้ช่วยจัดเรียงส่วนที่จับคู่ได้ใหม่

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+)-(\\d+)")
    fmt.Println(re.ReplaceAllString("12-34", "$2-$1"))
}

การอ้างอิงกลุ่มแบบมีชื่อ

เมื่อใช้กลุ่มแบบมีชื่อ คุณสามารถใช้ ${name} ในส่วนการแทนที่เพื่อให้โค้ดอ่านเข้าใจได้ชัดเจนขึ้น

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(?P<y>\\d{4})-(?P<m>\\d{2})")
    fmt.Println(re.ReplaceAllString("2026-05", "${m}/${y}"))
}

วงเล็บปีกกาที่ปลอดภัย

ใช้วงเล็บปีกกา ${1} เมื่อมีข้อความต่อท้ายการอ้างอิงกลุ่ม เพื่อไม่ให้ $1 ถูกเข้าใจผิดว่าเป็นชื่อที่ยาวกว่า

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\d+)")
    fmt.Println(re.ReplaceAllString("7", "${1}px"))
}

การแทนที่แบบตรงตัว

ReplaceAllLiteralString จะไม่สนใจการอ้างอิง $ และแทรกข้อความแทนที่ตรงตามที่เขียนไว้ทุกประการ

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    fmt.Println(re.ReplaceAllLiteralString("a1", "$money"))
}

แทนที่ด้วยฟังก์ชัน

ReplaceAllStringFunc จะเรียกฟังก์ชันของคุณสำหรับแต่ละส่วนที่จับคู่ได้ และแทนที่ด้วยค่าที่ฟังก์ชันส่งกลับ วิธีนี้ช่วยให้คำนวณค่าที่ใช้แทนที่ได้

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    re := regexp.MustCompile("[a-z]+")
    out := re.ReplaceAllStringFunc("go is fun", strings.ToUpper)
    fmt.Println(out)
}

การแทนที่ที่คำนวณ

ภายในฟังก์ชัน คุณสามารถแปลงแต่ละส่วนที่จับคู่ได้ตามต้องการ ในตัวอย่างนี้จะทำให้ชุดตัวเลขที่จับคู่ได้แต่ละชุดมีความยาวเป็นสองเท่าด้วยการครอบมันไว้

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    out := re.ReplaceAllStringFunc("id5 and id9", func(m string) string {
        return "<" + m + ">"
    })
    fmt.Println(out)
}

การปกปิดข้อมูลละเอียดอ่อน

การใช้งานจริงอย่างหนึ่งคือการปกปิดตัวเลข เช่น ชุดตัวเลขลักษณะเดียวกับหมายเลขบัตร ก่อนทำการบันทึกข้อมูล

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("\\d{4}")
    fmt.Println(re.ReplaceAllString("card 1234 5678", "****"))
}

การทำงานกับไบต์

นอกจากนี้ยังมีรูปแบบที่ทำงานกับไบต์ เช่น ReplaceAll ซึ่งมีลักษณะสอดคล้องกับเมธอดสำหรับสตริง และเหมาะกับข้อมูลไบนารีหรือข้อมูลในบัฟเฟอร์

package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("[0-9]+")
    out := re.ReplaceAll([]byte("a1b2"), []byte("#"))
    fmt.Println(string(out))
}

ตรวจสอบอย่างรวดเร็ว

คุณจะแทรกกลุ่มจับคู่กลุ่มแรกในสตริงแทนที่อย่างไร

ทบทวน: การแทนที่ข้อความ

คุณได้เรียนรู้การเขียนข้อความใหม่ดังนี้:

  • ReplaceAllString ใช้สลับส่วนที่จับคู่ได้ ส่วน $1/${name} ใช้อ้างอิงกลุ่ม
  • ReplaceAllLiteralString จะไม่ขยายการอ้างอิง
  • ReplaceAllStringFunc ใช้คำนวณค่าที่แทนที่แต่ละส่วน
package main

import (
    "fmt"
    "regexp"
)

func main() {
    re := regexp.MustCompile("(\\w+)\\s(\\w+)")
    fmt.Println(re.ReplaceAllString("Ada Lovelace", "$2, $1"))
}

คำถามที่พบบ่อย

บทเรียน “การแทนที่ข้อความ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การแทนที่ข้อความ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Go Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Go Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การแทนที่ข้อความ”

รูปแบบ ReplaceAll คุณปฏิบัติ Go Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Go Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Go Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การแทนที่ข้อความ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Go Academy นี้ได้ไหม

ได้ บทเรียน Go Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. พื้นฐาน regexp
  2. การค้นหาและแยกข้อมูล
  3. การแทนที่ข้อความ
  4. เคล็ดลับด้านประสิทธิภาพ
← กลับไปที่ Go Academy