Bagaimanakah Kita Boleh Mejadualkan Fungsi Generik Go Generik dengan Cekap dengan Jenis Argumen Yang Berbeza?

Menguji Fungsi Generik Table Go

Dalam Go 1.18, pengaturcara boleh memanfaatkan ciri generik baharunya. Semasa meneroka keupayaan baharu ini, pembangun mungkin menghadapi cabaran dalam melaksanakan ujian jadual. Satu cabaran sedemikian diterokai dalam perbincangan ini, terutamanya dalam konteks menguji fungsi generik dengan data jadual.

Isu ini timbul apabila cuba membuat instantiate fungsi generik dengan pelbagai jenis hujah semasa ujian jadual. Untuk menangani perkara ini, pembangun sering mengambil jalan untuk mengisytiharkan semula logik ujian untuk setiap fungsi, seperti yang ditunjukkan oleh coretan kod berikut:

package main

import (
    "testing"

    "github.com/stretchr/testify/assert"
)

type Item interface {
    int | string
}

type store[T Item] map[int64]T

// add adds an Item to the map if the id of the Item isn't present already
func (s store[T]) add(key int64, val T) {
    _, exists := s[key]
    if exists {
        return
    }
    s[key] = val
}

func TestStore(t *testing.T) {
    t.Run("ints", testInt)
    t.Run("strings", testString)
}

type testCase[T Item] struct {
    name     string
    start    store[T]
    key      int64
    val      T
    expected store[T]
}

func testString(t *testing.T) {
    t.Parallel()
    tests := []testCase[string]{
        {
            name:  "empty map",
            start: store[string]{},
            key:   123,
            val:   "test",
            expected: store[string]{
                123: "test",
            },
        },
        {
            name: "existing key",
            start: store[string]{
                123: "test",
            },
            key: 123,
            val: "newVal",
            expected: store[string]{
                123: "test",
            },
        },
    }
    for _, tc := range tests {
        t.Run(tc.name, runTestCase(tc))
    }
}

func testInt(t *testing.T) {
    t.Parallel()
    tests := []testCase[int]{
        {
            name:  "empty map",
            start: store[int]{},
            key:   123,
            val:   456,
            expected: store[int]{
                123: 456,
            },
        },
        {
            name: "existing key",
            start: store[int]{
                123: 456,
            },
            key: 123,
            val: 999,
            expected: store[int]{
                123: 456,
            },
        },
    }
    for _, tc := range tests {
        t.Run(tc.name, runTestCase(tc))
    }
}

func runTestCase[T Item](tc testCase[T]) func(t *testing.T) {
    return func(t *testing.T) {
        tc.start.add(tc.key, tc.val)
        assert.Equal(t, tc.start, tc.expected)
    }
}

Pendekatan ini, walau bagaimanapun, memerlukan logik ujian berlebihan untuk setiap fungsi. Intipati jenis generik terletak pada keupayaan mereka untuk bekerja dengan jenis sewenang-wenangnya, dan kekangan memastikan bahawa jenis sedemikian menyokong operasi yang sama.

Daripada menguji jenis yang berbeza secara berlebihan, adalah lebih berhemat untuk menumpukan pada menguji jenis tersebut sahaja. yang menunjukkan tingkah laku yang berbeza apabila menggunakan operator. Sebagai contoh, pengendali " " mempunyai makna yang berbeza untuk nombor (penjumlahan) dan rentetan (penggabungan), atau "" operator mempunyai tafsiran berbeza untuk nombor (lebih besar/kurang) dan rentetan (tertib leksikografi).

Untuk menggambarkan lebih lanjut isu ini, pembangun harus merujuk kepada perbincangan yang serupa di mana pengguna cuba melakukan ujian jadual dengan fungsi generik.

Atas ialah kandungan terperinci Bagaimanakah Kita Boleh Mejadualkan Fungsi Generik Go Generik dengan Cekap dengan Jenis Argumen Yang Berbeza?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!