فهم الجداول والعموديات في لغة Go

مقدمة

في Go, أرrays و البندان تمثلان أنماط البيانات التي تكون من تسلسل منظم من العناصر. تلك التراكم البيانية جيدة للاستخدام عندما تريد العمل مع العديد من القيم المرتبطة. تمكنك من حفظ البيانات المتعلقة مع بعضها البعض وتكسير كودك وقيامك بنفس الطرق والعمليات على قيم متعددة من قبل.

على الرغم من أن أرrays والبندان في Go كلاهما من تسلسلات منظمة من العناصر، فإن هناك فروابط مهمة بين الاثنين. يوجد أرray في Go هو أنماط البيانات التي تكون من تسلسل منظم من العناصر والذي يحدد كميته في الوقت المناسب. بمجرد تخصيص حجم الأرray بعدها، لا يمكن تغيير حجمه بعد. على الجانب الآخر، يوجد البندان هو نسخة تتغير في طولها من الأرrays، مما يوفر توفير أكثر للمطورين الذين يستخدمون هذه التراكم البيانية. تتمثل البندان في ما تفكر به بالأرrays في اللغات الأخرى.

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

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

الأعدادات

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

تعريف الأعدادة

يتم تعريف الأنظمة ب declaración del tamaño del array en los corchetes [ ], seguido del tipo de datos de los elementos. يتم تعريف الأنظمة en Go debe tener todos los elementos del mismo tipo de datos. Después del tipo de datos, puede declarar los valores individuales de los elementos del array en los corchetes { }.

El siguiente es el esquema general para declarar un array:

[capacity]data_type{element_values}

Si no declaras los valores de los elementos del array, el valor predeterminado es de cero, lo que significa que los elementos del array estarán vacíos. Para enteros, esto se representa por 0, y para cadenas, esto se representa por una cadena vacía.

Por ejemplo, el siguiente array numbers tiene tres elementos enteros que aún no tienen un valor:

var numbers [3]int

Si imprimes numbers, recibirás la siguiente salida:

Output
[0 0 0]

Si deseas asignar los valores de los elementos cuando cree el array, colócales en corchetes. Un array de cadenas con valores fijos se parece a esto:

[4]string{"blue coral", "staghorn coral", "pillar coral", "elkhorn coral"}

Puedes almacenar un array en una variable y imprimirlo:

coral := [4]string{"blue coral", "staghorn coral", "pillar coral", "elkhorn coral"}
fmt.Println(coral)

Ejecutar un programa con las líneas anteriores te daría la siguiente salida:

Output
[blue coral staghorn coral pillar coral elkhorn coral]

لا يوجد تنظيم بين العناصر في التوالي عند طباعتها ، مما يجعل من الصعب تحديد مكان نهاية عنصر واحد وبدء عنصر آخر. وبسبب هذا ، يمكن أحياناً استخدام ما يطلق عليه الكمando fmt.Printf بدلاً منه ، الذي يمكنه التشكيل للأحرف قبل طباعتها على الشاشة. أستخدم العبارة %q مع هذا الأمر لتوجيه المجموعة لوضع أقواس حول القيم:

fmt.Printf("%q\n", coral)

سينتج عن هذا التحويل التالي:

Output
["blue coral" "staghorn coral" "pillar coral" "elkhorn coral"]

والآن كل عنصر مسمد. العبارة \n توجيه المصمم إلى إضافة إنتقال خط في النهاية.

مع فكرة عامة عن كيفية تعريف الأرrays وما يتكون منهم يمكنك الآن التحديد لكيفية تعريف العناصر في الأرray بواسطة رقم من الفهرس.

تسمية الأرrays (والبعائد)

يمكن تسمية كل عنصر في الأرray (وأيضًا في البعائد) بشكل منفصل من خلال التسمية. كل عنصر يتماشى مع رقم من الفهرس وهو قيمة int تبدأ من الرقم الفرعي 0 وتعد في الأعلى.

سنستخدم أرray في المثالين التاليين ، لكن يمكنك أيضًا استخدام البعائد ، لأنهم متشابهون في كيفية تسمية العناصر لكل منهما.

للأرray coral ، تشكيل الفهرس يبدو مثل هذا:

الكلمة الأولة، هي "blue coral"، بداية في مقدمة 0 ، وسطة الإنتقال إلى صفحة 3 بعد الكلمة "elkhorn coral".

بcause كل element في مجموعة أو مستوى لهم رقم صفحة من خالل آخرة، نستعمل ذلك للدخالتين والمعلومات الثلاثية المتسلسلة.

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

fmt.Println(coral[1])

Output
staghorn coral

يمكننا إدخال كلمة من خالل مجموعة أو مستوى باستخدام معلومة +:

coral[0] = "blue coral"
coral[1] = "staghorn coral"
coral[2] = "pillar coral"
coral[3] = "elkhorn coral"

نماذجنا للحصول على كلمة من خالل المجموعة أو المستوى باستخدام رقم الصفحة، ولكننا سيتم إدخال كلمة من خالل آخرة باستخدام معلومة +.

fmt.Println(coral[18])

Output
panic: runtime error: index out of range

نماذجنا للحصول على كلمة "Sammy loves ".

fmt.Println(coral[-1])

Output
invalid array index -1 (index must be non-negative)

بالمستخدمة معلومة + للمزيد من الكلمات في المجموعة أو المستوى.

fmt.Println("Sammy loves " + coral[0])

Output
Sammy loves blue coral

نماذجنا للحصول على كلمة "blue coral" بداية في مقدمة 0، وسطة الإنتقال إلى صفحة 3 بعد الكلمة "elkhorn coral".

بالمستخدمة معلومة + للمزيد من الكلمات في المجموعة أو المستوى.

تعديل العناصر

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

إذا كنا نريد تغيير قيمة جزء الكلمة للعنصر في الموقع الرقمي 1 من المجموعة coral من "staghorn coral" إلى "foliose coral", يمكننا فعل ذلك بالتالي:

coral[1] = "foliose coral"

حينما نطبع coral، ستكون المجموعة مختلفة:

fmt.Printf("%q\n", coral)

Output
["blue coral" "foliose coral" "pillar coral" "elkhorn coral"]

حينما تعرف كيفية تغيير العناصر الفرديين في المجموعة أو القطع، دعونا ننظر إلى بعض الأدوات التي ستعطيكم مرونة أكبر عندما تعمل بأنواع الأعمال التي تتركب من البيانات.

عدد العناصر بواسطة len()

في Go، يعتبر len() وظيفة بنية داخلية تساعدك في العمل مع الأعدادات والقطع الصغيرة. مثل الأسطر التي يمكنك حساب طولها باستخدام len() ومن ثم تقبل معه الأعدادات أو القطع كما المادة المرتبطة.

على سبيل المثال، للبحث عن عدد العناصر في المجموعة coral ، يمكنك أن تستخدم:

len(coral)

إذا قمت بطباعة طول التركيب coral، ستحصل على الخروج التالي:

Output
4

هذا يعطي طول التركيب 4 في النوع int، وهو صحيح لأن التركيب coral لديه أربعة عناصر:

coral := [4]string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral"}

إذا أنشأت تركيب من الأعداد ذي عدد أكبر من العناصر، يمكنك أيضًا استخدام معمل len() على هذا:

numbers := [13]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
fmt.Println(len(numbers))

سينتج عن ذلك الخروج التالي:

Output
13

على الرغم من أن هذه الأمثلة التي تحتوي عدد قليل من العناصر، يمكن المعمل len() أيضًا أن يكون مفيدًا للتحقق من عدد العناصر في التركيبات الكبيرة جدًا.

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

إضافة عناصر بواسطة append()

المétodo append() هو مétodo بنية داخلي في Go يسمح لنا بإضافة عناصر إلى نوع تركيبي. ومع ذلك، لن يعمل هذا المétodo عند استخدامه مع التركيبات. كما ذكرنا من قبل، الطريقة الرئيسية التي تختلف التركيبات عن البعدات هي أن طول التركيبات لا يمكن تعديله. هذا يعني أنه يمكنك تغيير قيم العناصر في التركيب ومع ذلك لا يمكنك جعل التركيب أكبر أو أصغر بعد تعريفه.

دعونا ننظر إلى تركيبك coral:

coral := [4]string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral"}

وإذا كنت تريد أن تضيف العنصر "المرجان الأسود" إلى هذا التوالي، فإن سبيل المثال للاستخدام مع التوالي بواسطة وظيفة append() بكتابة:

coral = append(coral, "black coral")

ستحصل على خطأ كما ستراه في ما يلي:

Output
first argument to append must be slice; have [4]string

لإصلاح هذا، دعونا نتعلم المزيد عن نوع البيانات المتسلسلة القطع، كيفية تعريف البيانات المتسلسلة، وكيفية تحويل التوالي من التوالي القطعي.

البيانات المتسلسلة

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

تعريف البيانات المتسلسلة

يتم تعريف الأجزاء بعد إعلان نوع البيانات مساوية للوصف الفارغ (`[]`) وقائمة من العناصر بين الأقواس (`{}`). ستلاحظ أنه بخلاف المجموعات التي تتطلب عدد `int` بين الأقواس لتعريف الطول المحدد، فإن الأجزاء لا تحتوي على أي شيء بين الأقواس، مما يمثل طولها التفاضلي.

دعونا نخلق أجزاء تحتوي على عناصر نوع السطر النصي:

seaCreatures := []string{"shark", "cuttlefish", "squid", "mantis shrimp", "anemone"}

عندما نطبع الأجزاء، يمكننا رؤية العناصر التي تكون ضمن الأجزاء:

fmt.Printf("%q\n", seaCreatures)

سينتج عن هذا النتيجة التالية:

Output
["shark" "cuttlefish" "squid" "mantis shrimp" "anemone"]

إذا كنت تريد إنشاء أجزاء من الطول معين بدون تعبئة العناصر في المجموعة بعد، يمكنك استخدام معالجة داخلية `make()`:

oceans := make([]string, 3)

إذا طبعت هذا الأجزاء، ستحصل على:

Output
["" "" ""]

إذا كنت تريد تخزين الذاكرة لمجموعة معينة قبل تعبئتها، يمكنك تقديم المادة الثالثة لمعالجة `make()`:

oceans := make([]string, 3, 5)

سيصنع هذا الأجزاء مباشرة بمقدار 0 وبمجموعة قبلية من 5 عناصر.

لقد تعلمت كيفية تعريف الأجزاء الآن. ومع ذلك لم يحل هذا مشكلة المجموعة `coral` التي كان لدينا مسبقًا. للاستخدام مع `append()` مع `coral`، يجب أن تتعلم كيفية تقسيم الأجزاء من مجموعات الأعداد.

تقسيم المجموعات إلى أجزاء

باستخدام أعداد المؤشرات لتحديد النقاط البدئية والنهائية، يمكنك أن تستدعي جزء من القيم داخل تركيز. يطلق عليها تقطيع التركيز ، ويمكنك أن تفعل ذلك بإنشاء مجموعة من أعداد المؤشرات المفصلة بلوك ، بالطريقة [first_index:second_index]. ومن المهم أن تلاحظ فيما يتعلق بتقطيع التركيز، أن النتيجة هي قطعة وليس تركيز.

فلو أردت أن تطبع من العناصر الوسطي فقط من تركيز coral بدون العنصر الأول والأخير، يمكنك إنشاء قطعة تبدأ من المؤشر 1 وتنتهي قبل المؤشر 3:

fmt.Println(coral[1:3])

تشغيل برنامج مع هذه السطرة سيقدم ما يلي:

Output
[foliose coral pillar coral]

عندما تقوم بتقطيع القطعة كما في [1:3]، يعني الأول هو من أين يبدأ القطعة (مدمج)، والثاني هو مجموع الأول وعدد العناصر التي تريد تحصيلها:

array[starting_index : (starting_index + length_of_slice)]

في هذه الحالة قمت بمعرفة العنصر الثاني (أو مؤشر 1) كنقطة بدء، وسألت عن عدد عناصر يشمل ذلك. هذه هي كيفية الحساب:

array[1 : (1 + 2)]

وهذه هي توضيحة التوجيه:

coral[1:3]

إذا أردت أن تضع البدء أو النهاية من التركيز كنقطة بدء أو نهاية للقطعة، يمكنك تخفيف واحد من الأرقام في نمط array[first_index:second_index]. على سبيل المثال، إذا أردت أن تطبع الأول ثلاث عناصر من التركيز coral — الذي سيكون "blue coral"، "foliose coral" و "pillar coral" — يمكنك أن تكتب:

fmt.Println(coral[:3])

سيتم

Output
[blue coral foliose coral pillar coral]

تم طباعة بداية المصفوفة، وتوقف بالفعل قبل موضع 3.

لتضمين جميع العناصر في النهاية من المصفوفة، يتوجب عدم استخدام النمط الاعتيادي:

fmt.Println(coral[1:])

سيقدم هذا التنقل التالي:

Output
[foliose coral pillar coral elkhorn coral]

تم منا دور تحديد طريقة استخدام التنقل لتحديد الأجزاء الفريدة من المصفوفة. ومن ثم ستتعلم كيفية استخدام التنقل لتحويل المصفوفات بأكملها إلى تنقلات.

تحويل مصفوفة إلى تنقل

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

coral[:]

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

coralSlice := coral[:]

إذا طبعت coralSlice، ستحصل على الخروج التالي:

Output
[blue coral foliose coral pillar coral elkhorn coral]

حالياً، حاول إضافة العنصر black coral كما في قسم المصفوفة، باستخدام append() مع التنقل المحول جديد:

coralSlice = append(coralSlice, "black coral")
fmt.Printf("%q\n", coralSlice)

سيقوم هذا بإنتاج التنقل مع العنصر المضاف:

Output
["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral"]

يمكننا أيضًا إضافة أكثر من عنصر في عبارة واحدة append():

coralSlice = append(coralSlice, "antipathes", "leptopsammia")

Output
["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral" "antipathes" "leptopsammia"]

لتراكم جميع المقاطع الاثنين معًا، يمكنك استخدام append()، لكن يتوجب عليك توسيع الجوانب الثانية التي تتم تراكمها باستخدام تراكم المتغير البرمجي ...:

moreCoral := []string{"massive coral", "soft coral"}
coralSlice = append(coralSlice, moreCoral...)

Output
["blue coral" "foliose coral" "pillar coral" "elkhorn coral" "black coral" "antipathes" "leptopsammia" "massive coral" "soft coral"]

وبعد أن تعلمت كيفية تراكم عنصر في قطعة، سننظر إلى كيفية إزالة العنصر.

إزالة عنصر من القطعة

بخلاف اللغات الأخرى، لا يوفر الغو البرمجية المبنية لإزالة عنصر من القطعة. يتوجب إزالة العناصر من القطعة عن طريق التقطيع.

لإزالة عنصر، يتوجب عليك التقطيع عن العناصر قبل ذلك العنصر، ومن ثم التقطيع عن العناصر بعد ذلك العنصر، ومن ثم تراكم هذين القطعتين معًا بدون العنصر الذي تريد إزالته.

إذا كان i معدل العنصر الذي يتم إزالته، فإن نمط هذه العملية سيبدو مثل التالي:

slice = append(slice[:i], slice[i+1:]...)

من coralSlice، دعونا نأزل العنصر "elkhorn coral"، وهذا العنصر يوجد في موقع المقاطع الثالث 3،

coralSlice := []string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral", "black coral", "antipathes", "leptopsammia", "massive coral", "soft coral"}

coralSlice = append(coralSlice[:3], coralSlice[4:]...)

fmt.Printf("%q\n", coralSlice)

Output
["blue coral" "foliose coral" "pillar coral" "black coral" "antipathes" "leptopsammia" "massive coral" "soft coral"]

والآن لم يعد العنصر في موقع المقاطع 3، السطر "elkhorn coral"، موجودًا في قطعتنا coralSlice، بعد الإزالة.

نستطيع أيضًا حذف مناطق معينة بنفس المقاربة. فإن كنا نريد إزالة ليس فقط للعنصر "elkhorn coral"، ولكن أيضًا "black coral" و "antipathes" المذكورة. يمكننا استخدام نطاق في التعابير لتحقيق هذا:

coralSlice := []string{"blue coral", "foliose coral", "pillar coral", "elkhorn coral", "black coral", "antipathes", "leptopsammia", "massive coral", "soft coral"}

coralSlice = append(coralSlice[:3], coralSlice[6:]...)

fmt.Printf("%q\n", coralSlice)

هذا الكود سيأخذ بمفاده أواني 3، 4، و 5 من القطعة:

Output
["blue coral" "foliose coral" "pillar coral" "leptopsammia" "massive coral" "soft coral"]

وبعدما تعلمنا كيفية إضافة وإزالة عناصر من القطعة، دعونا ننظر إلى كيفية قياس كمية البيانات التي يمكن أن تحتوي عليها هذه القطعة في أي وقت.

قياس قدرة القطعة بواسطة cap()

لأن القطعات لها طول متغير، فليس الlen() وسيلة جيدة للتحقق من حجم هذا النوع من البيانات. بدلاً من ذلك، يمكنك استخدام وظيفة cap() لتعرف القدرة التي يمكن أن تحتوي عليها القطعة. هذا سيظهر لك كم يمكن أن تحتوي عليه القطعة من العناصر، وهي معينة بما يلزم من الذخيرة المختارة للقطعة بالفعل.

إستخدام متوافر لcap() هو لإنشاء قطعة مع عدد معين من العناصر ومن ثم ملئهم بالعناصر بالبرمجيات. هذا يتجنب من أي تخزين غير ضروري قد يحدث من استخدام append() لإضافة عناصر بعيدًا عن قدرة التخزين المسموح به بالفعل.

دعونا نأخذ مثالًا حيث نريد إنشاء قائمة من الأرقام من 0 إلى 3. يمكننا استخدام append() في دارة للقيام بذلك، أو يمكننا تخزين القطعة مسبقًا واستخدام cap() للدورة لملئ القيم.

أولًا، يمكننا النظر إلى استخدام append():

numbers := []int{}
for i := 0; i < 4; i++ {
	numbers = append(numbers, i)
}
fmt.Println(numbers)

Output
[0 1 2 3]

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

الآن دعونا نملأ القطعة بدون استخدام append() بتخزين طول/القدرة المسبقة:

numbers := make([]int, 4)
for i := 0; i < cap(numbers); i++ {
	numbers[i] = i
}

fmt.Println(numbers)

Output
[0 1 2 3]

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

بينما يعملان الاستراتيجيات append() و cap() بشكل وظيفي متشابه، تتفاعل المثال cap() بتجنب أي تخزين إضافي للذاكرة الذي كان يتطلب استخدام وظيفة append().

بناء قطع الأعداد المتعددة الأبعاد

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

دعونا ننظر إلى القطعة الأبعادية التالية:

seaNames := [][]string{{"shark", "octopus", "squid", "mantis shrimp"}, {"Sammy", "Jesse", "Drew", "Jamie"}}

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

fmt.Println(seaNames[1][0])
fmt.Println(seaNames[0][0])

في البرمجيات السابقة، أولاً نحني العنصر في المؤشر 0 للقطعة في المؤشر 1، ثم نبين عنصر 0 للقطعة في المؤشر 0. سينتج ذلك عنصرًا يبدو كهذا:

Output
Sammy
shark

المؤشرات الفرعية للعناصر الأخرين تلك التالية:

seaNames[0][0] = "shark"
seaNames[0][1] = "octopus"
seaNames[0][2] = "squid"
seaNames[0][3] = "mantis shrimp"

seaNames[1][0] = "Sammy"
seaNames[1][1] = "Jesse"
seaNames[1][2] = "Drew"
seaNames[1][3] = "Jamie"

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

خلاصة

في هذا الدرس التعليمي، تعلمت الأسس للعمل مع الأرrays والقطع المتداخلة في Go. مررت بعدة مادينات لتوضيح كيف تعمل الأرrays بطول ثابت، بينما تكون القطع المتداخلة بطول تناولي. واكتشفت كيف يؤثر هذا الفرق في استخدام هذه البنيات الداتا في أوضاع معينة.

للمتابعة في دراسة البنيات الداتا في Go، قم بمراجعة ما يلي مقالنا عن فهم الخرائط في Go، أو استكشف السلسلة الكاملة لـ كيفية كتابة البرمجيات باستخدام Go.