مقدمة في الأنواع العامة

جزء من قسم البرمجة كائنية التوجه في رحلة GO على Coddy. الدرس 67 من 107.

قبل Go 1.18، كانت كتابة شيفرة قابلة لإعادة الاستخدام مع أنواع مختلفة تعني إما تكرار الدوال أو استخدام الواجهة الفارغة any مع تأكيدات النوع. تحل الأنواع العامة هذه المشكلة إذ تتيح لك كتابة دوال وأنواع تعمل مع أنواع متعددة مع الحفاظ على سلامة الأنواع بالكامل.

تأمّل في إيجاد أصغر قيمة في شريحة. من دون الأنواع العامة، ستحتاج إلى دوال منفصلة لكل نوع:

func MinInt(values []int) int {
    min := values[0]
    for _, v := range values {
        if v < min {
            min = v
        }
    }
    return min
}

func MinFloat64(values []float64) float64 {
    min := values[0]
    for _, v := range values {
        if v < min {
            min = v
        }
    }
    return min
}

باستخدام الأنواع العامة، تكتب المنطق مرة واحدة باستخدام مَعْلَمة نوع بين أقواس مربعة:

func Min[T int | float64](values []T) T {
    min := values[0]
    for _, v := range values {
        if v < min {
            min = v
        }
    }
    return min
}

يُعلن [T int | float64] عن معلمة نوع T يمكن أن تكون إما int أو float64. الآن يمكنك استدعاء Min([]int{3, 1, 2}) أو Min([]float64{3.5, 1.2}) باستخدام الدالة نفسها. يتحقق المترجم من الأنواع أثناء الترجمة، لذا تحصل على الأمان دون أي عبء إضافي أثناء التشغيل.

في الدروس القادمة، سنتناول بالتفصيل معاملات الأنواع والقيود والبُنى العامة.

التحدي

سهل

لنُنشئ محللًا للدرجات يعمل مع الدرجات الصحيحة والعشرية باستخدام الأنواع العامة! ستنشئ دالة عامة واحدة يمكنها إيجاد أكبر قيمة في شريحة، مما يلغي الحاجة إلى تكرار الشيفرة لأنواع الأعداد المختلفة.

ستنظم شيفرتك في ملفين:

analyzer.go: عرّف دالة التحليل العامة.
أنشئ دالة عامة Max[T int | float64](values []T) T تبحث عن أكبر قيمة في شريحة وتعيدها. ينبغي أن تعمل الدالة مع النوعين int وfloat64 من خلال معامل النوع T.

أنشئ أيضًا دالة عامة Sum[T int | float64](values []T) T تحسب مجموع كل القيم في شريحة وتعيده.
main.go: اقرأ المدخلات واعرض دوالك العامة باستخدام أنواع مختلفة.
اقرأ مؤشرًا للنوع (int أو float)، ثم اقرأ عددًا يتبعه ذلك العدد من القيم. حلّل القيم وفقًا للنوع، واستدعِ كلًا من Max وSum بالنوع المناسب، ثم اطبع النتائج.

للمدخلات الصحيحة، اطبع:
```
Max (int): [value]
Sum (int): [value]
```
للمدخلات العشرية، اطبع مع منزلة عشرية واحدة:
```
Max (float): [value]
Sum (float): [value]
```

ستُوفَّر المدخلات التالية:

السطر 1: مؤشر النوع (int أو float)
السطر 2: عدد القيم (عدد صحيح)
الأسطر التالية: قيمة واحدة في كل سطر

على سبيل المثال، إذا كانت المدخلات:

فينبغي أن يكون الناتج:

Max (int): 23
Sum (int): 57

وإذا كانت المدخلات:

float
3
4.5
9.2
6.8

فينبغي أن يكون الناتج:

Max (float): 9.2
Sum (float): 20.5

لاحظ كيف تتعامل الدوال العامة نفسها مع البيانات الصحيحة والعشرية: يسمح معامل النوع [T int | float64] للمترجم بإنشاء شيفرة آمنة من حيث الأنواع لكل استخدام، بينما تكتب المنطق مرة واحدة فقط.

جرّب بنفسك

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// اقرأ مؤشر النوع
	typeStr, _ := reader.ReadString('\n')
	typeStr = strings.TrimSpace(typeStr)

	// اقرأ العدد
	countStr, _ := reader.ReadString('\n')
	count, _ := strconv.Atoi(strings.TrimSpace(countStr))

	if typeStr == "int" {
		// اقرأ القيم الصحيحة
		values := make([]int, count)
		for i := 0; i < count; i++ {
			line, _ := reader.ReadString('\n')
			values[i], _ = strconv.Atoi(strings.TrimSpace(line))
		}

		// TODO: استدعِ Max وSum مع شريحة من الأعداد الصحيحة
		// TODO: اطبع النتائج بالتنسيق "Max (int): [value]" و"Sum (int): [value]"

	} else if typeStr == "float" {
		// اقرأ قيم الأعداد العشرية
		values := make([]float64, count)
		for i := 0; i < count; i++ {
			line, _ := reader.ReadString('\n')
			values[i], _ = strconv.ParseFloat(strings.TrimSpace(line), 64)
		}

		// TODO: استدعِ Max وSum مع شريحة من float64
		// TODO: اطبع النتائج بمنزلة عشرية واحدة بالتنسيق "Max (float): [value]" و"Sum (float): [value]"
	}
}