Bagaimanakah Penegasan Jenis dan Suis Jenis Berprestasi Berbanding dengan Metodologi Semakan Jenis Lain?

Taip Penegasan dan Prestasi Suis dalam Go

Dalam bahasa pengaturcaraan, menentukan jenis pembolehubah atau objek semasa masa jalan ialah operasi asas. Go menggunakan penegasan jenis dan suis jenis untuk memudahkan proses ini. Artikel ini menyelidiki ciri prestasi teknik ini.

Kebimbangan Prestasi

Dalam sesetengah bahasa seperti C/C , penemuan jenis masa jalan boleh dikenakan penalti prestasi. Pengaturcara Go telah memikirkan sama ada penegasan jenis atau suis jenis menunjukkan ketidakcekapan yang sama. Untuk menangani perkara ini, mari kita lakukan penanda aras komprehensif:

package main

import (
    "fmt"
    "testing"
)

func question(anything interface{}) {
    switch v := anything.(type) {
        case string:
            fmt.Println(v)
        case int32, int64:
            fmt.Println(v)
        case SomeCustomType:
            fmt.Println(v)
        default:
            fmt.Println("unknown")
    }
}

Kod sampel menggunakan suis jenis untuk menentukan jenis pembolehubah input apa-apa.

Perbandingan Penanda Aras

Satu siri ujian penanda aras telah dijalankan untuk membandingkan prestasi penegasan jenis dan suis dengan panggilan kaedah langsung dan antara muka pelaksanaan:

package main

import (
    "testing"
)

type myint int64

type Inccer interface {
    inc()
}

func (i *myint) inc() {
    *i = *i + 1
}

func BenchmarkIntmethod(b *testing.B) {
    i := new(myint)
    incnIntmethod(i, b.N)
}

func BenchmarkInterface(b *testing.B) {
    i := new(myint)
    incnInterface(i, b.N)
}

func BenchmarkTypeSwitch(b *testing.B) {
    i := new(myint)
    incnSwitch(i, b.N)
}

func BenchmarkTypeAssertion(b *testing.B) {
    i := new(myint)
    incnAssertion(i, b.N)
}

func incnIntmethod(i *myint, n int) {
    for k := 0; k < n; k++ {
        i.inc()
    }
}

func incnInterface(any Inccer, n int) {
    for k := 0; k < n; k++ {
        any.inc()
    }
}

func incnSwitch(any Inccer, n int) {
    for k := 0; k < n; k++ {
        switch v := any.(type) {
        case *myint:
            v.inc()
        }
    }
}

func incnAssertion(any Inccer, n int) {
    for k := 0; k < n; k++ {
        if newint, ok := any.(*myint); ok {
            newint.inc()
        }
    }
}

Pada berbilang mesin ujian, keputusan secara konsisten mendedahkan bahawa keempat-empat kaedah berfungsi pada kelajuan yang sama: panggilan kaedah langsung, pelaksanaan antara muka, penegasan jenis dan suis jenis. Contoh berikut menunjukkan penemuan ini:

BenchmarkIntmethod-16           2000000000           1.67 ns/op
BenchmarkInterface-16           1000000000           2.03 ns/op
BenchmarkTypeSwitch-16          2000000000           1.70 ns/op
BenchmarkTypeAssertion-16       2000000000           1.67 ns/op

Oleh itu, kesimpulan kami ialah penegasan jenis dan suis jenis dalam Go tidak mengalami kemerosotan prestasi yang ketara jika dibandingkan dengan metodologi semakan jenis lain.

Atas ialah kandungan terperinci Bagaimanakah Penegasan Jenis dan Suis Jenis Berprestasi Berbanding dengan Metodologi Semakan Jenis Lain?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!