القطعة (Slice) بلغة Go

في لغة Go، الشريحة أكثرالمجموعةأقوى، مرن، مريح، ووزن خفيف. الشريحة هي سلسلة طولية قابلة للتغيير تستخدم لتحفظ العناصر من نفس النوع، ولا يُسمح بحفظ أنواع مختلفة في نفس الشريحة. مثل مجموعة تحتوي على قيم مرتبة بالترتيب، ولكن يمكن تعديل حجم الشريحة، الشريحة ليست مثل المجموعة في الحجم الثابت. في الداخل، الشريحة والمجموعة متصلة ببعضها البعض، الشريحة هي إشارة إلى المجموعة الأساسية. يُسمح بحفظ العناصر المكررة في الشريحة.الموقع الأول في الشريحة دائمًا 0، والموقع الأخير سيكون (طول الشريحة - 1).

إعلان الشريحة

إعلان الشريحة يشبه إعلان المجموعة، ولكن لا يحتوي على حجم الشريحة. لذا يمكنه التوسع أو縮شه حسب الحاجة.

القواعد:

[]T
أو
[]T{}
أو
[]T{value1, value2, value3, ...value n}

في هذا، T هو نوع العنصر. على سبيل المثال:

var my_slice[]int

مكونات الشريحة

الشريحة تحتوي على ثلاثة مكونات:

• النقطة:النقطة تعني إلى العنصر الأول الذي يمكن الوصول إليه عبر الشريحة. هنا، العنصر الذي يشير إليه لا يجب أن يكون العنصر الأول في المجموعة.

• الطول:الطول هو عدد العناصر الموجودة في المجموعة.

• سعة:سعة الاستيعاب تمثل الحجم الأقصى الذي يمكن توسيعه.

دعونا نناقش جميع هذه المكونات عبر مثال:

// الشريحة
package　main
إدراج "fmt"

　　　　// إنشاء مجموعة من الأعداد
　　　　arr := [7]string{"هذا", "هذا", "Golang", "أساسي", "تعليمي", "عبر الإنترنت", "ar.oldtoolbag.com"}
　　　　// عرض المجموعة
　　　　fmt.Println("المجموعة:", arr)
　　　　
　　　　myslice := arr[1:6]
　　　　// عرض الشريحة
　　　　fmt.Println("الشريحة:", myslice)
　　　　// عرض طول الشريحة
　　　　fmt.Printf("طول الشريحة: %d", len(myslice))
　　　　// عرض سعة الشريحة
　　　　fmt.Printf("\nسعة الشريحة: %d", cap(myslice))
}

الناتج:

مجموعة: [هذا هو تعليمي Golang الأساسي عبر الإنترنت ar.oldtoolbag.com]
القطعة: [Golang أساس درس عبر الإنترنت]
طول القطعة: 5
عرض القطعة: 6

توضيح الاستخدام:في المثال السابق، أنشأنا قطعة من مجموعة الأعداد. هنا، يشير سهم القطعة إلى المؤشر 1، لأن الحد الأدنى للقطعة تم تعيينه إلى 1، لذا يبدأ في الوصول إلى العناصر من المؤشر 1. طول القطعة هو 5، مما يعني عدد العناصر في القطعة هو 5، وعرض القطعة هو 6، مما يعني أن يمكن تخزين 6 عنصرًا في أقصى درجة.

كيف يمكن إنشاء وتحديد قطعة؟

في لغة Go، يمكنك استخدام الطريقة التالية لإنشاء وتحديد قطعة:

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

  var my_slice_1 = []string{"w3codeboxs", "for", "w3codeboxs"}

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

  示例

  // استخدامه كقطعة من قطعة
  package　main
  إدراج "fmt"
  
  　　　　// استخدام كلمة المفتاح var لإنشاء قطعة
  　　　　var my_slice_1 = []string{"w3codeboxs", "for", "w3codeboxs"}
  　　　　fmt.Println("My Slice 1:", my_slice_1)
  　　　　
  　　　　// استخدام الت��عير القصير
  　　　　my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
  　　　　fmt.Println("My Slice 2:", my_slice_2)
  }

  الناتج:

  My Slice 1: [w3codeboxs for w3codeboxs]
  My Slice 2: [12 45 67 56 43 34 45]

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

  القواعد:

  array_name[low:high]

  هذه الجملة ستعود قطعة جديدة.

  ملاحظة:الحد الأدنى الافتراضي هو 0، والحد الأعلى الافتراضي هو عدد العناصر الموجودة في مجموعة الأعداد.

• 示例

  // إنشاء قطعة من مجموعة الأعداد
  package　main　
  　　
  إدراج "fmt"
  　　
  　
  　　
  　　　　// إنشاء مجموعة من الأعداد
  　　　　arr := [4]string{"w3codeboxs", "for", "w3codeboxs", "GFG"}　
  　　
  　　　　// من أجل إنشاء قطعة من مجموعة الأعداد　
  　　　　var my_slice_1 = arr[1:2]　
  　　　　my_slice_2 := arr[0:]　
  　　　　my_slice_3 := arr[:2]　
  　　　　my_slice_4 := arr[:]　
  　　
  　　　　// عرض النتيجة
  　　　　fmt.Println("عددي:", arr)　
  　　　　fmt.Println("قطعة Me 1:", my_slice_1)　
  　　　　fmt.Println("قطعة Me 2:", my_slice_2)　
  　　　　fmt.Println("قطعة Me 3:", my_slice_3)　
  　　　　fmt.Println("قطعة Me 4:", my_slice_4)　
  }

  الناتج:

  عددي: [w3codeboxs for w3codeboxs GFG]
  قطعة Me 1: [for]
  قطعة Me 2: [w3codeboxs for w3codeboxs GFG]
  قطعة Me 3: [w3codeboxs for]
  قطعة Me 4: [w3codeboxs for w3codeboxs GFG]

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

  القواعد:

  slice_name[low:high]

  هذه الجملة ستعود قطعة جديدة.

  ملاحظة:الحد الأدنى للافتراض هو 0، والحد الأعلى للافتراض هو عدد العناصر الموجودة في القطعة المعطاة.

  示例

  // إنشاء قطعة من قطعة
  package　main
  إدراج "fmt"
  
  　　　　
  　　　　oRignAl_slice := []int{90, 60, 40, 50, 34, 49, 30}
  　　　　// إنشاء قطعة من قطعة معطاة
  　　　　var my_slice_1 = oRignAl_slice[1:5]
  　　　　my_slice_2 := oRignAl_slice[0:]
  　　　　my_slice_3 := oRignAl_slice[:6]
  　　　　my_slice_4 := oRignAl_slice[:]
  　　　　my_slice_5 := my_slice_3[2:4]
  　　　　// عرض النتيجة
  　　　　fmt.Println("قطعة الأصلية:", oRignAl_slice)
  　　　　fmt.Println("جديد قطعة 1:", my_slice_1)
  　　　　fmt.Println("جديد قطعة 2:", my_slice_2)
  　　　　fmt.Println("جديد قطعة 3:", my_slice_3)
  　　　　fmt.Println("شريط جديد 4:", my_slice_4)
  　　　　fmt.Println("شريط جديد 5:", my_slice_5)
  }

  الناتج:

  شريط الأصل: [90 60 40 50 34 49 30]
  شريط جديد 1: [60 40 50 34]
  شريط جديد 2: [90 60 40 50 34 49 30]
  شريط جديد 3: [90 60 40 50 34 49]
  شريط جديد 4: [90 60 40 50 34 49 30]
  شريط جديد 5: [40 50]

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

  القواعد:

  func make([]T, len, cap) []T

  示例

  //استخدام make وظيفة
  package　main
  إدراج "fmt"
  
  　　　　//إنشاء مصفوفة بحجم 7
  　　　　//قطع هذا المصفوفة إلى 4
  　　　　//ويعود مرجع الشريط
  　　　　//استخدام make وظيفة
  　　　　var my_slice_1 = make([]int, 4, 7)
  　　　　fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n",my_slice_1, len(my_slice_1), cap(my_slice_1))
  　　　　//إنشاء مصفوفة أخرى بحجم 7
  　　　　//ويعود مرجع الشريط
  　　　　//استخدام make وظيفة
  　　　　var my_slice_2 = make([]int, 7)
  　　　　fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n",my_slice_2, len(my_slice_2), cap(my_slice_2))
  }

  الناتج:

  Slice 1 = [0 0 0 0],　
  length = 4,　
  capacity = 7
  Slice 2 = [0 0 0 0 0 0 0],　
  length = 7,　
  capacity = 7

كيفية تمرير الشريط؟

يمكنك التمرير عبر الشريط باستخدام الطريقة التالية:

• استخدام حلقة for:هذه هي أبسط طريقة لتكرار الشريط، كما هو موضح في المثال التالي:

  示例

  //تحسين حلقة for في الشريط
  package　main　
  　　
  إدراج "fmt"
  　　
  　
  　　
  　　　　
  　　　　// في دائرة for باستخدام range القطعة بدون مؤشر　
  　　
  　　　　//استخدام حلقة for للتحسين
  　　　　لـ e := 0; e < len(myslice); e++ {　
  　　　　　　　　fmt.Println(myslice[e])　
  　　　　}　
  }

  الناتج:

  This
  is
  fmt.Println(myslice[e])
  This
  هو
  التعليمات
  من

• Goاللغة

  示例

  في دائرة for باستخدام range:
  package　main　
  　　
  إدراج "fmt"
  　　
  　
  　　
  　　　　
  　　　　// في دائرة for باستخدام range القطعة بدون مؤشر　
  　　
  　　　　　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}
  　　　　　　　　// تكرار قطعة باستخدام range
  　　　　يسمح لك استخدام نطاق في دائرة for بتكرار القطعة. في دائرة for باستخدام range، يمكنك الحصول على مؤشر القيمة والعنصر، مثل المثال التالي:　
  　　　　　　　　// في دائرة for باستخدام range القطعة　
  　　　　}　
  }

  الناتج:

  for index, ele := range myslice {
  fmt.Printf("Index = %d و العنصر = %s\n", index+3, ele)
  مؤشر = 4 و العنصر = This
  مؤشر = 5 و العنصر = هو
  مؤشر = 6 و العنصر = التعليمات
  مؤشر = 7 و العنصر = من
  مؤشر = 8 و العنصر = Go

• مؤشر = 9 و العنصر = اللغةفي دائرة for باستخدام رمز التشويه في دائرة for
  

  示例

  في نطاق، إذا لم تكن تريد الحصول على قيمة مؤشر العنصر، يمكنك استخدام مساحة ( _) كنوع مؤشر، مثل المثال التالي:　
  package　main　
  　　
  إدراج "fmt"
  　　
  　
  　　
  　　　　　
  　　　　// في دائرة for باستخدام range القطعة بدون مؤشر　
  　　
  　　　　　　　　myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"}
  　　　　　　　　// تكرار قطعة باستخدام range
  　　　　　　　　// في دائرة for باستخدام range
  　　　　// لا يوجد مؤشر　
  　　　　　　　　for _, ele := range myslice {　
  　　　　}　
  }

  الناتج:

  fmt.Printf("Element = %s\n", ele)
  المكون = This
  المكون = هو
  المكون = التعليمات
  المكون = من
  المكون = Go
  المكون = اللغة

نقاط مهمة حول القطع

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

   示例

   package　main　
   　　
   إدراج "fmt"
   　　
   　
   　　
   　　　　// 创建零值切片
   　　　　var myslice []string　
   　　　　fmt.Printf("Length = %d\n", len(myslice))　
   　　　　fmt.Printf("السعة = %d ", cap(myslice))　
   　　
   }

   الناتج:

   الطول = 0
   السعة = 0

2. تعديل Slice:كما نعلم جميعًا أن slice نوع مرجعي، يمكنه مرجع النظام الأساسي. لذا، إذا قمنا بتعديل بعض العناصر في الشظية، فإن التعديل يجب أن يحدث أيضًا في النظام الأساسي المرجعي. بمعنى آخر، إذا قمت بأي تعديل على الشظية، فسيتم تعديل الشظية أيضًا، كما هو موضح في المثال التالي:

   示例

   //كيفية تعديل الشظية
   package　main　
   　　
   إدراج "fmt"
   　　
   　
   　　
   　　　　//إنشاء شظية صفر
   　　　　arr := [6]int{55, 66, 77, 88, 99, 22}　
   　　　　slc := arr[0:4]　
   　　
   　　　　//قبل التعديل
   　　
   　　　　fmt.Println("Original_Array: ", arr)　
   　　　　fmt.Println("Original_Slice: ", slc)　
   　　
   　　　　//بعد التعديل　
   　　　　slc[0] = 100　
   　　　　slc[1] = 1000　
   　　　　slc[2] = 1000　
   　　
   　　　　fmt.Println("\nNew_Array: ", arr)　
   　　　　fmt.Println("New_Slice: ", slc)　
   }

   الناتج:

   Original_Array: [55 66 77 88 99 22]
   Original_Slice: [55 66 77 88]
   New_Array: [100 1000 1000 88 99 22]
   New_Slice: [100 1000 1000 88]

3. مقارنة الشظايا:في الشظية، يمكنك استخدام فقط==دالة التحقق من وجود الشظية المقدمة.==إذا كنت تستخدم دالة المساواة، فإنها ستقوم بإلقاء خطأ، مثل المثال التالي:

   示例

   //تحقق من ما إذا كانت الشظية صفر
   package　main　
   　　
   إدراج "fmt"
   　　
   　
   　　
   　　　　
   　　　　s1 := []int{12, 34, 56}　
   　　　　var s2 []int
   　　
   　　　　　　　　//إذا حاولت تشغيل هذه التعليقات
   　　　　　　　　//سيقدم معالج الكود خطأ
   　　　　/*s3:= []int{23, 45, 66}*/　
   　　　　　　fmt.Println(s1 == s3)　
   　　　　*/
   　　
   　　　　//تحقق من ما إذا كانت الشظية المقدمة فارغة
   　　　　fmt.Println(s1 == nil)　
   　　　　fmt.Println(s2 == nil)　
   }

   الناتج:

   خطأ
   صحيح

   ملاحظة:إذا كنت ترغب في مقارنة شظيتين، يمكنك استخدام حلقة تكرارية لمطابقة كل عنصر، أو يمكنك استخدامDeepEqualالوظائف.

4. الشظايا المتعددة：الشظايا المتعددة تشبه الأنظمة المتعددة، ولكن الشظايا لا تحتوي على حجم.

   示例

   package　main　
   　　
   إدراج "fmt"
   　　
   　
   　　
   　　　　//创建多维切片
   　　　　s1　:=　[][]int{{12,　34},　
   　　　　　　　　{56,　47},　
   　　　　　　　　{29,　40},　
   　　　　　　　　{46,　78},　
   　　　　}　
   　　
   　　　　//访问多维切片
   　　　　fmt.Println("Slice　1　:　",　s1)　
   　　
   　　　　//创建多维切片　
   　　　　s2　:=　[][]string{　
   　　　　　　　　[]string{"w3codeboxs",　"for"},　
   　　　　　　　　[]string{"w3codeboxs",　"GFG"},　
   　　　　　　　　[]string{"gfg",　"w3codebox"},　
   　　　　}　
   　　
   　　　　//访问多维切片
   　　　　fmt.Println("Slice　2　:　",　s2)　
   　　
   }

   الناتج:

   Slice　1　:　　[[12　34]　[56　47]　[29　40]　[46　78]]
   Slice　2　:　　[[w3codeboxs　for]　[w3codeboxs　GFG]　[gfg　w3codebox]]

5. 切片排序：在Go语言中，可以对切片中存在的元素进行排序。 　Go语言的标准库提供了sort包，其中包含用于对int，float64和字符串切片进行排序的不同类型的排序方法。 这些函数始终按升序对可用元素进行切片排序。

   示例

   //切片中存在的元素
   package　main　
   　　
   import　(　
   　　　　"fmt"
   　　　　"sort"
   )　
   　　
   　
   　　
   　　　　
   　　　　slc1 := []string{"Python", "Java", "C#　
   　　　　slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89}　
   　　
   　　　　fmt.Println("قبل الترتيب:")　
   　　　　fmt.Println("قطعة 1: ", slc1)　
   　　　　fmt.Println("قطعة 2: ", slc2)　
   　　
   　　　　//استخدام وظائف ترتيب الفصائل
   　　　　sort.Strings(slc1)　
   　　　　sort.Ints(slc2)　
   　　
   　　　　fmt.Println("
   مقسومًا:")　
   　　　　fmt.Println("قطعة 1: ", slc1)　
   　　　　fmt.Println("قطعة 2: ", slc2)　
   　　
   }

   الناتج:

   قبل الترتيب:
   قطعة 1: [Python Java C# Go Ruby]
   قطعة 2: [45 67 23 90 33 21 56 78 89]
   مقسومًا:
   قطعة 1: [C# Go Java Python Ruby]
   قطعة 2: [21 23 33 45 56 67 78 89 90]