Go، المعروفة أيضًا باسم Golang، هي لغة مكتوبة بشكل ثابت. وهذا يعني أن نوع كل متغير معروف في وقت الترجمة، مما يوفر الأمان والقدرة على التنبؤ في التعليمات البرمجية الخاصة بك. إلا أن هذا يتطلب أيضًا أن يكون أي تحويل من نوع إلى آخر صريحًا ومتعمدًا. في هذه المقالة، سنستكشف آليات تحويل النوع المختلفة المتاحة في Go، بدءًا من التحويلات الرقمية الأساسية وحتى تحويلات الواجهة والمؤشر الأكثر تعقيدًا.

1. تحويلات النوع الأساسي

يسمح Go بالتحويل بين الأنواع الأساسية مثل الأعداد الصحيحة، وأرقام الفاصلة العائمة، والسلاسل، ولكن يجب إجراء هذه التحويلات بشكل صريح.

أنواع رقمية

التحويلات بين الأنواع الرقمية المختلفة واضحة ولكن يجب أن تكون صريحة:

var i int = 42
var f float64 = float64(i)  // int to float64
var u uint = uint(i)        // int to uint

في هذا المثال، نقوم بتحويل int إلى float64 وإلى uint. هذه التحويلات صريحة لأن Go لا يقوم بإجراء تحويلات تلقائية (ضمنية).

سلسلة وشريحة بايت

سلاسل Go غير قابلة للتغيير، ولكن يمكن تحويلها من وإلى شرائح البايت ([]byte)، وهي قابلة للتغيير:

var s string = "hello"
var b []byte = []byte(s)   // string to []byte
var s2 string = string(b)  // []byte to string

وبالمثل، يمكنك التحويل بين السلاسل وشرائح الرون ([]rune)، حيث يكون الرون اسمًا مستعارًا للنوع int32:

var r []rune = []rune(s)   // string to []rune
var s3 string = string(r)  // []rune to string

2. تحويلات النوع المخصص

في Go، يمكنك تحديد الأنواع الخاصة بك بناءً على الأنواع الموجودة. التحويلات بين الأنواع المخصصة والأنواع الأساسية الخاصة بها واضحة:

type MyInt int
var i int = 10
var mi MyInt = MyInt(i)   // int to MyInt
var i2 int = int(mi)      // MyInt to int

يعد هذا التحويل الصريح ضروريًا للتأكد من قدرة المترجم على التحقق من سلامة التعليمات البرمجية الخاصة بك.

3. تحويلات المؤشر

تشير المؤشرات الموجودة في Go إلى عنوان ذاكرة المتغير. يمكنك التحويل بين القيمة ومؤشرها:

var x int = 42
var p *int = &x     // int to *int (pointer to int)
var y int = *p      // *int to int (dereferencing)

4. تحويلات نوع الواجهة

تُستخدم الواجهات في Go لتحديد مجموعة من الأساليب. يمكنك التحويل بين أنواع وواجهات الخرسانة:

var a interface{} = 42    // int to interface{}
var b int = a.(int)       // interface{} to int (type assertion)

نوع التأكيدات

يوفر تأكيد النوع الوصول إلى القيمة الملموسة للواجهة:

if v, ok := a.(int); ok {
    fmt.Println("a is an int:", v)
}

اكتب التبديل

يسمح لك مفتاح النوع بتنفيذ إجراءات مختلفة بناءً على النوع الديناميكي للواجهة:

switch v := a.(type) {
case int:
    fmt.Println("a is an int:", v)
case string:
    fmt.Println("a is a string:", v)
default:
    fmt.Println("a is of unknown type")
}

5. التحويلات غير الآمنة

تسمح لك الحزمة غير الآمنة بتجاوز أمان النوع Go، وتمكين التحويلات التي قد تكون غير قانونية:

import "unsafe"

var i int = 42
var p *int = &i
var fp *float64 = (*float64)(unsafe.Pointer(p))  // *int to *float64

تحذير: يجب استخدام التحويلات غير الآمنة باعتدال وفقط عند الضرورة القصوى، لأنها يمكن أن تؤدي إلى سلوك غير محدد.

6. تحويلات نوع القناة

تعد القنوات ميزة قوية في Go، مما يسمح بالاتصال بين goroutines. يمكنك التحويل بين القنوات ثنائية الاتجاه وأحادية الاتجاه:

ch := make(chan int)
var sendOnlyChan chan




  
  
  7. تحويلات البنية والصفيف


تتطلب التحويلات بين البنيات أو المصفوفات ذات التخطيطات المتطابقة صبًا صريحًا:


type Point struct {
    X, Y int
}

type Coord struct {
    X, Y int
}

var p Point = Point{1, 2}
var c Coord = Coord(p)  // Convert Point to Coord (same field types)





  
  
  8. تحويلات الشريحة


الشرائح هي إشارات إلى المصفوفات، وبينما يمكنك التحويل بين شرائح من نفس النوع، فإن التحويل بين أنواع مختلفة من الشرائح يتطلب تحويلاً صريحًا:


var a []int = []int{1, 2, 3}
var b []int = a[1:]  // Convert a slice to another slice of the same type





  
  
  9. لا توجد تحويلات للواجهة


يمكن تعيين قيمة صفرية في Go لأي نوع واجهة:


var x interface{} = nil
var y error = nil





  
  
  10. تحويلات نوع الوظيفة


يمكن تحويل وظائف Go إلى أنواع مختلفة، بشرط أن تكون التوقيعات متوافقة:


type FuncType func(int) int

func square(x int) int {
    return x * x
}

var f FuncType = FuncType(square)  // Convert function to FuncType





  
  
  11. تحويل الصفيف إلى شريحة


يمكنك إنشاء شريحة من مصفوفة، والتي تعد في الأساس مرجعًا للمصفوفة:


var arr [5]int = [5]int{1, 2, 3, 4, 5}
var sl []int = arr[:]  // Convert array to slice





  
  
  خاتمة


 تكون عملية تحويل الكتابة والتحويلات في Go واضحة حسب التصميم، مما يجعل التعليمات البرمجية أكثر أمانًا وأسهل للفهم. من خلال طلب تحويلات صريحة، يساعد Go في منع الأخطاء الدقيقة التي يمكن أن تنشأ من الإكراه الضمني على الكتابة، وهو أمر شائع في بعض لغات البرمجة الأخرى. يعد فهم هذه التحويلات واستخدامها بشكل صحيح أمرًا بالغ الأهمية لكتابة برامج Go قوية وفعالة.