templat kelas pelaksanaan golang

Golang ialah bahasa pengaturcaraan yang pantas, cekap dan boleh dipercayai sesuai untuk membina aplikasi web dan perkhidmatan rangkaian. Ciri yang kaya dan sintaksnya yang ringkas telah menjadikan Golang sangat popular sejak beberapa tahun kebelakangan ini. Di Golang, melaksanakan templat kelas adalah teknik pengaturcaraan biasa. Artikel ini akan memperkenalkan cara menggunakan Golang untuk melaksanakan templat kelas.

1. Pengenalan
Di Golang, tiada mekanisme pewarisan kelas tradisional. Tetapi terdapat beberapa teknik yang membolehkan kita mencapai ciri yang serupa dengan pengaturcaraan berorientasikan objek. Salah satu helah tersebut ialah melaksanakan templat kelas. Templat kelas ialah jenis templat yang mentakrifkan jenis umum yang boleh digunakan pada jenis konkrit yang berbeza. Sama seperti kelas generik Java atau kelas templat C++. Templat kelas di Golang boleh dilaksanakan menggunakan antara muka.

2. Definisi antara muka
Di Golang, antara muka ialah koleksi kaedah. Sebarang jenis yang melaksanakan semua kaedah dalam antara muka boleh dipanggil jenis pelaksanaan antara muka. Sebagai contoh, yang berikut mentakrifkan jenis antara muka yang mengandungi kaedah yang diisytiharkan sebagai Do():

type Doer interface {
    Do() error
}

Antara muka ini mewakili sesuatu yang boleh "melakukan". Operasi "do" dilaksanakan oleh kaedah Do().

3. Kaedah pelaksanaan
Yang berikut akan menggunakan kes khusus untuk menerangkan cara menggunakan Golang untuk melaksanakan templat kelas. Kami akan melaksanakan antara muka Logger, dan sebarang jenis yang melaksanakan antara muka ini boleh digunakan untuk mengeluarkan log.

Pertama, kami mentakrifkan antara muka Logger dan struktur LogEvent:

type Logger interface {
    Log(event LogEvent)
}

type LogEvent struct {
    Level     string
    Message   string
    Timestamp time.Time
}

Antara muka ini mentakrifkan kaedah Log(), yang boleh menerima struktur LogEvent dan mengeluarkannya. Struktur ini mewakili peristiwa log, yang mengandungi maklumat seperti tahap, mesej dan cap masa.

Seterusnya, kami melaksanakan antara muka Logger untuk tahap log yang berbeza:

type ConsoleLogger struct {
    Level string
}

func (l ConsoleLogger) Log(event LogEvent) {
    if event.Level == l.Level {
        fmt.Println(event.Timestamp, event.Level, event.Message)
    }
}

type FileLogger struct {
    Level string
    File  *os.File
}

func (l FileLogger) Log(event LogEvent) {
    if event.Level == l.Level {
        l.File.Write([]byte(fmt.Sprintf("%s %s %s 
", event.Timestamp, event.Level, event.Message)))
    }
}

Kod di atas melaksanakan dua jenis log: ConsoleLogger dan FileLogger.

ConsoleLogger bermaksud mengeluarkan log ke konsol; Walau bagaimanapun, kod pelaksanaan untuk kedua-dua jenis mempunyai persamaan. Oleh itu, kita boleh mengabstrakkan kod ini ke dalam templat kelas untuk mencapai penggunaan semula kod.

4. Pelaksanaan templat kelas
Kami akan mentakrifkan templat kelas untuk mengabstrakkan ciri umum Logger Templat ditakrifkan seperti berikut:

type AbstractLogger struct {
    Level string
}

func (l AbstractLogger) Log(event LogEvent) {
    if event.Level == l.Level {
        l.Process(event)
    }
}

func (l AbstractLogger) Process(event LogEvent) {
    panic("Not implemented")
}

Ia mentakrifkan Logger abstrak. struktur, Ia mengandungi kaedah Log() dan kaedah Proses() yang sangat biasa. Kaedah Log() ialah kaedah biasa yang mesti dilaksanakan oleh semua orang, manakala kaedah Proses() memerlukan subkelas untuk melaksanakan kaedah tertentu.

Kita boleh mewarisi AbstractLogger dan kemudian mengatasi kaedah Process() untuk melaksanakan kaedah output log tertentu:

type ConsoleLogger struct {
    AbstractLogger
}

func (l ConsoleLogger) Process(event LogEvent) {
    fmt.Println(event.Timestamp, event.Level, event.Message)
}

type FileLogger struct {
    AbstractLogger
    File *os.File
}

func (l FileLogger) Process(event LogEvent) {
    l.File.Write([]byte(fmt.Sprintf("%s %s %s 
", event.Timestamp, event.Level, event.Message)))
}

Akhir sekali, kita boleh mencipta contoh Logger dan menggunakan kod untuk mengeluarkan log:

func main() {
    file, _ := os.Create("app.log")
    defer file.Close()

    logger := ConsoleLogger{AbstractLogger{"info"}}
    logger.Log(LogEvent{"debug", "debug message", time.Now()}) // 该条日志不会被输出
    logger.Log(LogEvent{"info", "info message", time.Now()})   // 输出: 当前时间 info info message

    logger = FileLogger{AbstractLogger{"info"}, file}
    logger.Log(LogEvent{"info", "info message", time.Now()}) // 输出到文件中
}

Dalam kod di atas, kami mencipta contoh ConsoleLogger untuk output log dan contoh FileLogger untuk output fail log. Hanya satu log dikeluarkan pada konsol kerana LogLevel ditetapkan kepada maklumat dan LogLevel bagi log pertama ialah nyahpepijat, yang tidak memenuhi syarat output. Log yang sama ditulis pada fail dan akhirnya output ke app.log fail.

5. Ringkasan
Walaupun tiada mekanisme pewarisan kelas dalam Java atau C++ dalam Golang, kami boleh menggunakan antara muka untuk mencapai pewarisan yang serupa. Melaksanakan templat kelas dalam Golang ialah teknik yang sangat berguna, yang boleh membantu kami menggunakan semula kod biasa dan meningkatkan kebolehselenggaraan kod. Kod sampel di atas menunjukkan cara menggunakan Golang untuk melaksanakan templat kelas dan menyediakan penyelesaian penggunaan semula kod untuk kelas log.

Atas ialah kandungan terperinci templat kelas pelaksanaan golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!