سويفت (لغة برمجة)

تدعم لغة Swift أنظمة تشغيل Apple ( Darwin و iOS و iPadOS و macOS و tvOS و watchOS ) و Linux و Windows و WebAssembly و Android . ^{[ 54 ] [ 55 ]}

من أهم جوانب تصميم لغة Swift قدرتها على التفاعل مع الكم الهائل من أكواد Objective-C الموجودة والمطورة لمنتجات Apple على مدى العقود الماضية، مثل Cocoa وإطار عمل Cocoa Touch . على منصات Apple، ^{[ 56 ]} ترتبط Swift بمكتبة وقت تشغيل Objective-C ، مما يسمح بتشغيل أكواد C و Objective-C و C++ وSwift ضمن برنامج واحد. ^{[ 57 ]}

يشبه بناء جملة لغة Swift لغات البرمجة من نمط C. يبدأ تنفيذ التعليمات البرمجية في النطاق العام افتراضيًا. ^{[ 80 ]} بدلاً من ذلك، يمكن تطبيق السمة على تعريف بنية أو فئة أو تعداد للإشارة إلى أنها تحتوي على نقطة دخول البرنامج. ^{[ 81 ]}@main

برنامج "Hello, World!" الخاص بلغة Swift هو:

print ( "مرحباً بالعالم!" )

الدالة المستخدمة هنا مُضمنة في مكتبة Swift القياسية، وهي متاحة لجميع البرامج دون الحاجة إلى استيراد وحدات خارجية. لا يشترط أن تنتهي العبارات في Swift بفاصلة منقوطة، ولكن الفاصلة المنقوطة ضرورية لفصل العبارات المتعددة المكتوبة على نفس السطر. تبدأ التعليقات أحادية السطر بـ `<br> ` وتستمر حتى نهاية السطر الحالي. أما التعليقات متعددة الأسطر فتُحاط بـ `<br>` و `<br>`. تُعلن الثوابت ( المتغيرات التي لا يمكن تعديلها) باستخدام الكلمة المفتاحية `<br>`، بينما يمكن تغيير المتغيرات المُعلنة باستخدام الكلمة المفتاحية `<br>`. يجب تهيئة القيم قبل قراءتها. يمكن للمتغيرات استنتاج نوعها بناءً على نوع القيمة الأولية المُقدمة. إذا تم تعيين القيمة الأولية بعد إعلان القيمة، فيجب تحديد نوعها صراحةً. ^{[ 80 ]}print(_:separator:terminator:)///**/letvar

let highScoreThreshold = 1000 // ثابت من النوع Int. تم استنتاج النوع بناءً على القيمة المقدمة.var currentScore = 980 // متغير من النوع Int.currentScore = 1200 // يمكن أن تتغير قيمة المتغيرات بمرور الوقت.let playerMessage : String // ثابت من النوع String.إذا كانت النتيجة الحالية أكبر من عتبة أعلى نتيجة {playerMessage = "أنت لاعب ممتاز!"} آخر {playerMessage = "حظًا أوفر في المرة القادمة."}print ( playerMessage ) // يطبع "أنت لاعب ممتاز!"

تُدار عملية التحكم في تدفق التعليمات البرمجية في لغة Swift باستخدام عبارات if-else و guard و switch ، بالإضافة إلى حلقات while و for-in . تأخذ هذه العبارات مُعاملًا منطقيًا (Boolean) وتُنفذ محتوى العبارة إذا كان الشرط صحيحًا، وإلا تُنفذ المحتوى الاختياري. يوفر بناء الجملة اختصارًا برمجيًا للتحقق من وجود قيمة اختيارية وفك تغليفها في الوقت نفسه.ififelseif-let

لنفترض أن العدد 42إذا كان باقي قسمة عدد ما على 2 يساوي صفرًا { // استخدم عامل الباقي لإيجاد باقي قسمة عدد ما على 2.print ( " \( someNumber ) هو عدد زوجي." )} آخر {print ( " \( someNumber ) is odd." )}// يطبع "42 عدد زوجي".

تُعرَّف الدوال باستخدام الكلمة funcالمفتاحية. قد تحمل معاملات الدوال أسماءً تُسهِّل قراءة استدعاءات الدوال كعبارات. يسمح وضع شرطة سفلية قبل اسم المعامل بحذف تسمية الوسيط من موقع الاستدعاء. يمكن للدوال استخدام المجموعات لإرجاع بيانات متعددة دفعة واحدة.

func constructGreeting ( for name : String ) -> String {أعد "مرحباً \( الاسم ) !"}let greeting = constructGreeting ( for : "Craig" )print ( greeting ) // يطبع "مرحباً كريج!"

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

دالة القسمة على اثنين ( _ aNum : Int ) -> Int {أعد aNum / 2}func multiplyByTwo ( _ aNum : Int ) -> Int {أعد aNum * 2}let mathOperation = multiplyByTwoprint ( mathOperation ( 21 )) // يطبع "42"

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

دالة القسمة ( البسط : عدد صحيح ؟، المقام : عدد صحيح ) -> عدد صحيح ؟ {تحقق من أن المقام لا يساوي صفرًا وإلا {print ( "لا يمكن القسمة على صفر." )إرجاع قيمة فارغة}guard let numerator else {print ( "البسط المقدم يساوي صفرًا." )إرجاع قيمة فارغة}إرجاع البسط / المقام}let result = divide ( numerator : 3 , byDenominator : 0 )print ( "نتيجة القسمة هي: \( result ) " )// يطبع:// "لا يمكن القسمة على صفر."// "نتيجة القسمة هي: لا شيء."

switchتقارن العبارات قيمةً ما مع عدة قيم محتملة، ثم تُنفّذ كتلة التعليمات البرمجية المرتبطة بها. switchيجب أن تكون العبارات شاملة، إما بتضمين حالات لجميع القيم الممكنة، أو بتضمين defaultحالة تُنفّذ عندما لا تتطابق القيمة المُقدّمة مع أي من الحالات الأخرى. switchلا تتلاشى الحالات ضمنيًا، على الرغم من إمكانية حدوث ذلك صراحةً باستخدام fallthroughالكلمة المفتاحية `require`. يمكن استخدام مطابقة الأنماط بطرق متنوعة داخل switchالعبارات. إليك مثال على مطابقة عدد صحيح مع عدد من النطاقات المحتملة:

لنفترض أن العدد 42مفتاح بعض الأرقام {الحالة ..< 0 :print ( " \( someNumber ) negative." )الحالة 0 :print ( " \( someNumber ) is 0." )الحالة 1. .. 9 :print ( " \( someNumber ) أكبر من 0، ولكن أقل من 10." )تقصير :print ( " \( someNumber ) أكبر من 9." )}// يطبع "42 أكبر من 9".

for-inتتكرر الحلقات على سلسلة من القيم:

let names = [ "Will" , "Anna" , "Bart" ]لكل اسم في قائمة الأسماء {اطبع ( الاسم )}// يطبع:// سوف// آنابارت

whileتستمر الحلقات في التكرار طالما أن الشرط المنطقي المحدد يُقيّم إلى true:

// اجمع كل الأرقام من 1 إلى 5.المتغير i = 1var result = 0while i <= 5 { // تقوم الحلقة بتنفيذ جسمها طالما أن i أقل من أو يساوي 5. result += i // أضف i إلى النتيجة الحالية.i += 1 // زيادة قيمة i بمقدار 1.}print ( result ) // يطبع "15"

تدعم لغة Swift الدوال المغلقة ، وهي عبارة عن وحدات وظيفية مستقلة يمكن تمريرها واستخدامها في الكود، ^{[ 82 ]} ويمكن استخدامها أيضًا كدوال مجهولة . إليك بعض الأمثلة:

// يمكن تحديد نوع الإغلاق، المحدد بواسطة قيم الإدخال والإخراج الخاصة به، خارج الإغلاق:let closure1 : ( Int , Int ) -> Int = { arg1 , arg2 inأعد arg1 + arg2}// …أو داخله:let closure2 = { ( arg1 : Int , arg2 : Int ) -> Int inأعد arg1 + arg2}// في معظم الحالات، يمكن للمترجم استنتاج نوع الإرجاع للدالة المغلقة تلقائيًا.let closure3 = { arg1 : Int , arg2 : Int inأعد arg1 + arg2}

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

تتميز لغة Swift أيضاً بصيغة الإغلاق اللاحق، والتي تسمح بكتابة الإغلاق بعد نهاية استدعاء الدالة بدلاً من داخل قائمة معاملات الدالة. ويمكن حذف الأقواس تماماً إذا كان الإغلاق هو المعامل الوحيد للدالة.

// تأخذ هذه الدالة دالة مغلقة لا تستقبل أي معلمات إدخال وتعيد عددًا صحيحًا،// يقوم بتقييمها، ويستخدم قيمة الإرجاع الخاصة بالإغلاق (عدد صحيح) كقيمة إرجاع للدالة.دالة foo ( قاطعة الإغلاق : () -> عدد صحيح ) -> عدد صحيح {return bar ()}// بدون صيغة الإغلاق اللاحقة:foo ( closure : { return 1 })// مع صيغة الإغلاق اللاحقة، والإرجاع الضمني:foo { 1 }

ابتداءً من الإصدار 5.3، يدعم Swift إغلاقات لاحقة متعددة: ^{[ 83 ]}

// تمرر هذه الدالة القيمة المُعادة من الإغلاق الأول كمعامل للإغلاق الثاني، // وتعيد نتيجة الإغلاق الثاني: func foo ( bar : () -> Int , baz : ( Int ) -> Int ) -> Int { return baz ( bar ()) }// بدون إغلاقات لاحقة: foo ( bar : { return 1 }, baz : { x in return x + 1 })// مع إغلاق لاحق واحد: foo ( bar : { return 1 }) { x in return x + 1 }// مع وجود دالتين إغلاق لاحقتين (تم حذف اسم وسيط الدالة الأولى فقط): foo { return 1 } baz : { x in return x + 1 }

ستوفر لغة Swift أسماءً مختصرة للوسائط في الدوال المغلقة المضمنة، مما يُغني عن الحاجة إلى تسمية جميع معاملات هذه الدوال صراحةً. ^{[ 84 ]} يمكن الإشارة إلى الوسائط بالأسماء $0، $1، $2، وهكذا.

let names = [ "جوزفين" , "ستيف" , "كريس" , "باربرا" ]// تستدعي الدالة filter الدالة المُعطاة لكل قيمة في قائمة الأسماء. // يتم الاحتفاظ بالقيم التي يقل عدد أحرفها عن 6، ويتم حذف الباقي. let shortNames = names.filter { $ 0.count < 6 }print ( shortNames ) // يطبع "["Steve", "Chris"]"

قد تستخلص الدوال المغلقة قيمًا من نطاقها المحيط. وستشير الدالة المغلقة إلى هذه القيمة المستخلصة طالما بقيت الدالة المغلقة موجودة.

func makeMultiplier ( withMultiple multiple : Int ) -> ( Int ) -> ( Int ) { // إنشاء وإرجاع دالة مغلقة تأخذ عددًا صحيحًا كمدخل وتعيد المدخل مضروبًا في قيمة المضاعف. return { $0 * multiple } }let multiplier = makeMultiplier ( withMultiple : 3 ) print ( multiplier ( 3 )) // يطبع "9" print ( multiplier ( 10 )) // يطبع "30"

تتضمن مكتبة Swift القياسية أنواعًا متوافقة مع Unicode String. Characterيمكن تهيئة قيم السلاسل النصية باستخدام سلسلة نصية حرفية، وهي عبارة عن سلسلة من الأحرف محاطة بعلامات اقتباس مزدوجة. يمكن دمج السلاسل النصية باستخدام +المعامل:

var someString = "Hello،" someString += "world!"

تتيح عملية استيفاء السلاسل إنشاء سلسلة نصية جديدة من قيم وتعبيرات أخرى. \سيتم إدراج القيم المكتوبة بين قوسين مسبوقة بـ في السلسلة النصية المحيطة بها: ^{[ 85 ]}

var currentScore = 980 print ( "درجتك هي \( currentScore ) ." )// يطبع "درجتك هي 980."

يمكن استخدام حلقة for-in للتكرار على الأحرف الموجودة في سلسلة نصية:

for character in "Swift" { print ( character ) } // S // w // i // f // t

إذا تم استيراد إطار عمل Foundation، فإن Swift يقوم بشكل غير مرئي بربط نوع String بـ NSString (فئة String المستخدمة بشكل شائع في Objective-C).

تدعم لغة Swift خمسة مستويات للتحكم في الوصول للرموز: open`<T>` public، internal`<T>`، fileprivate`<T>`، و`< privateT>`. على عكس العديد من لغات البرمجة كائنية التوجه، تتجاهل هذه المستويات التسلسل الهرمي للوراثة : ` private<T>` يشير إلى أن الرمز متاح فقط في النطاق المباشر ، ` fileprivate<T>` يشير إلى أنه متاح فقط من داخل الملف، `<T>` internalيشير إلى أنه متاح داخل الوحدة الحاوية، `<T> ` publicيشير إلى أنه متاح من أي وحدة، و open(فقط للفئات وطرقها) يشير إلى أنه يمكن إنشاء فئات فرعية من الفئة خارج الوحدة. ^{[ 87 ]}

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

تُنشأ الأنواع الاختيارية باستخدام Optionalالتعداد. لإنشاء عدد صحيح يقبل القيم الفارغة، يُستخدم تعريف مشابه لـ ` . كما هو الحال في لغة C#، <sup>[ 88 ]</sup> تتضمن لغة Swift أيضًا اختصارًا برمجيًا لهذا الغرض، يسمح بالإشارة إلى أن المتغير اختياري بوضع علامة استفهام بعد اسم النوع . <sup>[ 89 ]</sup> المتغيرات أو الثوابت التي تُحدد على أنها اختيارية إما أن يكون لها قيمة من النوع الأساسي أو تكون فارغة . تُغلف الأنواع الاختيارية النوع الأساسي، مما ينتج عنه نسخة مختلفة. وهما نوعان مختلفان جوهريًا، فالأول من النوع `، بينما الثاني هو تعداد قد يحمل قيمة ما.var optionalInteger: Optional<Int>var optionalInteger: Int?nilStringString?StringOptionalString

للوصول إلى القيمة الموجودة بالداخل، بافتراض أنها ليست فارغة (nil)، يجب فك تغليفها لعرض الكائن الموجود بداخلها. ويتم ذلك باستخدام !المعامل التالي:

let myValue = anOptionalInstance !. someMethod ()

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

let myValue = anOptionalInstance ?. someMethod ()

في هذه الحالة، لا يتم استدعاء وقت التشغيل someMethodإلا إذا anOptionalInstanceلم تكن الخاصية فارغة، مما يؤدي إلى تجاهل الخطأ. ?يجب وضع `a` بعد كل خاصية اختيارية. إذا كانت أي من هذه الخصائص فارغة، فسيتم تقييم التعبير بأكمله على أنه فارغ. أصل مصطلح " التسلسل" يأتي من الحالة الأكثر شيوعًا حيث يتم ربط عدة استدعاءات/دوال جلب معًا. على سبيل المثال:

let aTenant = aBuilding.tenantList [ 5 ] let theirLease = aTenant.leaseDetails let leaseStart = theirLease ? .startDate​​​​

يمكن اختصارها إلى:

let leaseStart = aBuilding.tenantList [ 5 ] .leaseDetails ? .startDate​​

يسمح استخدام Swift للخيارات للمترجم باستخدام الإرسال الثابت لأن إجراء فك التغليف يتم استدعاؤه على مثيل محدد (الغلاف)، بدلاً من حدوثه في نظام إرسال وقت التشغيل.

في العديد من لغات البرمجة كائنية التوجه، تُمثَّل الكائنات داخليًا بجزأين. يُخزَّن الكائن ككتلة بيانات في الذاكرة الديناميكية (heap )، بينما يُمثَّل اسمه (أو "مؤشره") بمؤشر . تُمرَّر الكائنات بين الدوال بنسخ قيمة المؤشر، مما يسمح لأي شخص لديه نسخة بالوصول إلى نفس البيانات الأساسية في الذاكرة الديناميكية. في المقابل، تُمثَّل الأنواع الأساسية مثل الأعداد الصحيحة والأعداد العشرية مباشرةً؛ إذ يحتوي المؤشر على البيانات نفسها، وليس مؤشرًا إليها، وتُمرَّر هذه البيانات مباشرةً إلى الدوال بنسخها. يُطلق على أساليب الوصول هذه اسم " التمرير بالمرجع" في حالة الكائنات، و "التمرير بالقيمة" في حالة الأنواع الأساسية.

لكلٍّ من المفهومين مزايا وعيوب. تُعدّ الكائنات مفيدةً عندما تكون البيانات كبيرة، مثل وصف نافذة أو محتويات مستند. في هذه الحالات، يتم الوصول إلى تلك البيانات بنسخ قيمة 32 أو 64 بت، بدلاً من نسخ بنية بيانات كاملة. مع ذلك، فإن القيم الأصغر، مثل الأعداد الصحيحة، لها نفس حجم المؤشرات (عادةً ما يكون كلاهما كلمة واحدة )، لذا لا توجد ميزة لتمرير مؤشر بدلاً من تمرير القيمة.

توفر لغة Swift دعمًا مدمجًا للكائنات باستخدام دلالات التمرير بالمرجع أو التمرير بالقيمة، حيث يستخدم الأول التصريح class، بينما يستخدم الثاني struct. تتمتع الهياكل في Swift بجميع ميزات الفئات تقريبًا: الأساليب، وتنفيذ البروتوكولات، واستخدام آليات التوسيع. لهذا السبب، تُطلق Apple على جميع البيانات بشكل عام اسم مثيلات ، بدلاً من كائنات أو قيم. مع ذلك، لا تدعم الهياكل الوراثة. ^{[ 90 ]}

للمبرمج حرية اختيار الدلالات الأنسب لكل بنية بيانات في التطبيق. تُعرَّف البنى الأكبر حجمًا، مثل النوافذ، كفئات، مما يسمح بتمريرها كمؤشرات. أما البنى الأصغر، مثل نقطة ثنائية الأبعاد، فيمكن تعريفها كبنى، والتي تُمرَّر بالقيمة وتتيح الوصول المباشر إلى بياناتها الداخلية دون أي توجيه غير مباشر أو عدّ للمراجع. إن تحسين الأداء المتأصل في مفهوم تمرير القيمة كبيرٌ لدرجة أن لغة Swift تستخدم هذه الأنواع لجميع أنواع البيانات الشائعة تقريبًا، بما في ذلك أنواع البيانات وأنواع البيانات التي Intتُمثَّل Doubleعادةً بالكائنات، مثل أنواع Stringالبيانات وأنواع البيانات Array. ^{[ 90 ]} كما أن استخدام أنواع القيم قد يُحسِّن أداء تطبيقات المستخدم بشكل ملحوظ. ^{[ 91 ]}

Arrayتستخدم جميعها Dictionaryتقنية النسخ عند الكتابة ، بحيث لا تُنسخ بياناتها إلا عند محاولة البرنامج تغيير قيمة فيها. وهذا يعني أن لكل دالة وصول مؤشرًا إلى نفس وحدة تخزين البيانات. لذا ، فبينما تُخزن البيانات فعليًا كنسخة واحدة في الذاكرة، فإن هذه القيم منفصلة على مستوى التطبيق، ويُفرض الفصل المادي باستخدام تقنية النسخ عند الكتابة فقط عند الحاجة. ^{[ 92 ]}Set

تُضيف الإضافات وظائف جديدة إلى نوع موجود، دون الحاجة إلى إنشاء فئة فرعية أو حتى الوصول إلى شفرة المصدر الأصلية. يمكن للإضافات إضافة طرق جديدة، وقيم ابتدائية، وخصائص محسوبة، وفهارس، وتوافقات بروتوكول. ^{[ 93 ]} على سبيل المثال، يمكن إضافة مدقق إملائي إلى Stringالنوع الأساسي، مما يعني أن جميع مثيلات هذا النوع Stringفي البرنامج ستكتسب القدرة على التدقيق الإملائي. يُستخدم هذا النظام أيضًا على نطاق واسع كتقنية تنظيمية، حيث يسمح بتجميع الشفرة ذات الصلة في إضافات شبيهة بالمكتبات.

يتم تعريف الامتدادات باستخدام extensionالكلمة المفتاحية.

struct Rectangle {let width : Doublelet height : Double}امتداد مستطيل {var area : Double {إرجاع الارتفاع * العرض}}

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

في لغة Objective-C، ومعظم اللغات الأخرى التي تُطبّق مفهوم البروتوكول، يقع على عاتق المبرمج ضمان تنفيذ الطرق المطلوبة في كل فئة. ^{[ 94 ]} تُضيف لغة Swift إمكانية إضافة هذه الطرق باستخدام الامتدادات، واستخدام البرمجة العامة (generics) لتنفيذها. يسمح الجمع بين هذين الأمرين بكتابة البروتوكولات مرة واحدة ودعم مجموعة واسعة من الحالات. كما يُمكن استخدام آلية الامتدادات لإضافة توافق البروتوكول إلى كائن لا يُدرج هذا البروتوكول في تعريفه. ^{[ 95 ]}

على سبيل المثال، قد يتم الإعلان عن بروتوكول يسمى Printable، مما يضمن أن الحالات التي تتوافق مع البروتوكول تنفذ descriptionشرطًا يتعلق بالخاصية وشرطًا printDetails()يتعلق بالأسلوب:

// تعريف بروتوكول باسم Printable protocol Printable { var description : String { get } // شرط خاصية للقراءة فقط func printDetails () // شرط دالة }

يمكن الآن اعتماد هذا البروتوكول من قبل أنواع أخرى:

// تطبيق بروتوكول Printable في فئة class MyClass : Printable { var description : String { return " An instance of MyClass" }func printDetails () { print ( description ) } }

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

extension Printable { // ستتلقى جميع مثيلات Printable هذا التنفيذ، أو يمكنها تعريف تنفيذها الخاص. func printDetails () { print ( description ) } }// أصبح نوع Bool الآن متوافقًا مع Printable، ويرث تنفيذ printDetails() المذكور أعلاه. extension Bool : Printable { var description : String { return "An instance of Bool with value: \( self ) " }}

في لغة Swift، كما هو الحال في العديد من اللغات الحديثة التي تدعم الواجهات، يمكن استخدام البروتوكولات كأنواع، مما يعني أنه يمكن تعريف المتغيرات والأساليب بواسطة البروتوكول بدلاً من نوعها المحدد:

func getSomethingPrintable () -> any Printable { return true }var someSortOfPrintableInstance = getSomethingPrintable () print ( someSortOfPrintableInstance . description )// يطبع "نسخة من نوع Bool بقيمة: صحيح"

لا يهم نوع البيانات المحدد someSortOfPrintableInstance، فالمترجم سيضمن توافقها مع البروتوكول، وبالتالي فإن هذا الكود آمن. ويعني هذا التركيب أيضًا أن المجموعات يمكن أن تستند إلى بروتوكولات، مثل let printableArray = [any Printable]...

تُستخدم كلٌّ من الامتدادات والبروتوكولات على نطاق واسع في مكتبة Swift القياسية؛ ففي Swift 5.9، شكّلت البروتوكولات ما يقارب 1.2% من جميع الرموز في المكتبة القياسية، بينما شكّلت متطلبات البروتوكولات أو تطبيقاتها الافتراضية 12.3% أخرى. ^{[ 96 ]} على سبيل المثال، تستخدم Swift الامتدادات لإضافة Equatableالبروتوكول إلى العديد من أنواعها الأساسية، مثل السلاسل النصية والمصفوفات، مما يسمح بمقارنتها باستخدام ==المعامل. Equatableكما يُحدّد البروتوكول هذا التطبيق الافتراضي.

func !=< T : Equatable >( lhs : T , rhs : T ) -> Bool

تُعرّف هذه الدالة طريقةً تعمل على أي كائن مُطابق للمواصفات Equatable، وتُوفّر عامل " لا يساوي" . أي كائن، سواءً كان فئةً أو بنيةً، يكتسب هذا التنفيذ تلقائيًا بمجرد مطابقته للمواصفات Equatable. ^{[ 97 ]}

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

مصفوفة الامتداد حيث العنصر : قابل للمساواة {// ستكون الدالة allEqual متاحة فقط على عناصر المصفوفة التي تحتوي على عناصر قابلة للمساواة. func allEqual ( ) -> Bool { for element in self { if element != self.first { return false } } return true } }

أدخلت لغة Swift 5.5 ميزة التزامن المنظم. ^{[ 98 ]} يستخدم التزامن المنظم صيغة Async/await المشابهة للغات Kotlin وJavaScript وRust. تُعرَّف الدالة غير المتزامنة باستخدام الكلمة asyncالمفتاحية async/await بعد قائمة المعاملات. عند استدعاء دالة غير متزامنة، awaitيجب كتابة الكلمة المفتاحية async/await قبل اسم الدالة للإشارة إلى احتمال تعليق التنفيذ أثناء استدعاء الدالة. أثناء تعليق الدالة، قد يُشغِّل البرنامج دالة متزامنة أخرى ضمن نفس البرنامج. تُمكِّن هذه الصيغة البرامج من تحديد نقاط التعليق المحتملة بوضوح وتجنب ما يُعرف بـ "هرم الهلاك" الناتج عن الاستخدام الواسع النطاق سابقًا لدوال الاستدعاء المغلقة. ^{[ 99 ]}

func downloadText ( name : String ) async -> String { let result = // ... بعض التعليمات البرمجية غير المتزامنة للتنزيل ... return result }let text = await downloadText ( "text1" )

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

// سيتم تنفيذ كل استدعاء من هذه الاستدعاءات للدالة downloadText بالتوازي. async let text1 = downloadText ( name : "text1" ) async let text2 = downloadText ( name : "text2" ) async let text3 = downloadText ( name : "text3" )let textToPrint = await [ text1 , text2 , text3 ] // يُعلق التنفيذ حتى يتم استدعاء جميع استدعاءات downloadText الثلاثة بنجاح. print ( textToPrint )

يمكن إنشاء المهام ومجموعات المهام بشكل صريح لإنشاء عدد ديناميكي من المهام الفرعية أثناء وقت التشغيل:

let taskHandle = Task { await downloadText ( name : "someText" ) }let result = await taskHandle.value​​

تستخدم لغة Swift نموذج الممثل (Actor) لعزل الحالة القابلة للتغيير، مما يسمح لمهام مختلفة بتعديل الحالة المشتركة بطريقة آمنة. يتم تعريف الممثلين باستخدام actorالكلمة المفتاحية `on`، وهم أنواع مرجعية، مثل الفئات. لا يمكن إلا لمهمة واحدة الوصول إلى الحالة القابلة للتغيير للممثل في الوقت نفسه. يمكن للممثلين الوصول إلى حالتهم الداخلية وتعديلها بحرية، ولكن يجب على التعليمات البرمجية التي تعمل في مهام منفصلة وضع علامة على كل وصول باستخدام الكلمة awaitالمفتاحية `on` للإشارة إلى أنه يمكن تعليق التعليمات البرمجية حتى تنتهي المهام الأخرى من الوصول إلى حالة الممثل.

دليل الممثلين { var names : [ String ] = [] func add ( name : String ) { names . append ( name ) } }let directory = Directory ()// يتوقف تنفيذ الكود مؤقتًا حتى تنتهي المهام الأخرى من الوصول إلى الكائن. await directory.add ( name : " Tucker" ) print ( await directory.names )

في أنظمة أبل، يستخدم Swift نفس بيئة التشغيل الخاصة بنظام Objective-C الحالي ، ولكنه يتطلب نظام iOS 7 أو macOS 10.9 أو أحدث. كما يعتمد على Grand Central Dispatch . ^{[ 100 ]} يمكن استخدام كود Swift وObjective-C في برنامج واحد، وبالتالي، يمكن استخدام كود C وC++ أيضًا. بدءًا من Swift 5.9، يمكن استخدام كود C++ مباشرةً من كود Swift. ^{[ 101 ]} في حالة Objective-C، يتمتع Swift بإمكانية وصول واسعة إلى نموذج الكائنات، ويمكن استخدامه لإنشاء فئات فرعية وتوسيعها واستخدام كود Objective-C لتوفير دعم البروتوكولات. ^{[ 102 ]} لا ينطبق العكس: لا يمكن إنشاء فئات فرعية من فئة Swift في Objective-C. ^{[ 103 ]}

لتسهيل تطوير هذه البرامج، وإعادة استخدام الشيفرة البرمجية الموجودة، يوفر Xcode 6 والإصدارات الأحدث نظامًا شبه آلي يُنشئ ويُحدّث ملف رأس وسيطًا لعرض شيفرة Objective-C لـ Swift. يأتي هذا النظام على شكل ملف رأس إضافي يُعرّف أو يستورد جميع رموز Objective-C التي تحتاجها شيفرة Swift الخاصة بالمشروع. عندئذٍ، يُمكن لـ Swift الإشارة إلى الأنواع والدوال والمتغيرات المُعلنة في تلك الاستيرادات كما لو كانت مكتوبة بلغة Swift. كما يُمكن لشيفرة Objective-C استخدام شيفرة Swift مباشرةً، وذلك باستيراد ملف رأس مُحدّث تلقائيًا يحتوي على تعريفات Objective-C لرموز Swift الخاصة بالمشروع. على سبيل المثال، يُمكن لملف Objective-C في مشروع مختلط يُسمى "MyApp" الوصول إلى فئات أو دوال Swift باستخدام الشيفرة #import "MyApp-Swift.h". ومع ذلك، لا تتوفر جميع الرموز من خلال هذه الآلية - فقد يؤدي استخدام ميزات خاصة بلغة Swift مثل الأنواع العامة، والأنواع الاختيارية غير الكائنية، والتعدادات المتطورة، أو حتى معرفات Unicode إلى جعل الرمز غير قابل للوصول إليه من Objective-C. ^{[ 104 ]}

تدعم لغة Swift بشكل محدود السمات ، وهي بيانات وصفية يقرأها بيئة التطوير، وليست بالضرورة جزءًا من الكود المُترجم. وكما هو الحال في Objective-C، تستخدم السمات @صيغةً معينة، ولكن المجموعة المتاحة حاليًا محدودة. ومن الأمثلة على ذلك @IBOutletالسمة `output`، التي تُحدد قيمةً معينةً في الكود كمنفذ ، متاح للاستخدام داخل Interface Builder (IB). والمنفذ هو أداة تربط قيمة العرض على الشاشة بكائن في الكود.

في الأنظمة غير التابعة لشركة آبل، لا تعتمد لغة Swift على بيئة تشغيل Objective-C أو مكتبات نظام آبل الأخرى؛ إذ تحل محلها مجموعة من تطبيقات Swift "Corelib". وتشمل هذه التطبيقات "swift-corelibs-foundation" التي تحل محل Foundation Kit ، و"swift-corelibs-libdispatch" التي تحل محل Grand Central Dispatch، و"swift-corelibs-xctest" التي تحل محل واجهات برمجة تطبيقات XCTest من Xcode . ^{[ 105 ]}

ابتداءً من عام 2019، ومع إصدار Xcode 11، أضافت Apple نموذجًا جديدًا رئيسيًا لواجهة المستخدم يُسمى SwiftUI. يحل SwiftUI محل نموذج Interface Builder القديم بنموذج تطوير تصريحي جديد. ^{[ 106 ]}

تستخدم لغة Swift آلية عدّ المراجع التلقائي (ARC) لإدارة الذاكرة . يحتفظ كل مثيل من فئة أو دالة مغلقة بعداد مراجع يُسجّل عدد المراجع التي يحتفظ بها البرنامج. عندما يصل هذا العداد إلى الصفر، يتم تحرير المثيل. يُغني هذا التحرير التلقائي عن الحاجة إلى جامع البيانات المهملة، حيث يتم تحرير المثيلات بمجرد انتهاء الحاجة إليها.

قد تحدث حلقة مرجعية قوية إذا أشار مثيلان إلى بعضهما البعض بشكل مباشر (مثلاً، يشير A إلى B، ويشير B إلى A). ولأن عدد المراجع لأي من المثيلين لا يمكن أن يصل إلى الصفر، فإنهما لا يُحرران من الذاكرة، مما يؤدي إلى تسرب الذاكرة . توفر لغة Swift الكلمات المفتاحية `references` weakو` unownedreferences` لمنع الحلقات المرجعية القوية. تسمح هذه الكلمات المفتاحية بالإشارة إلى مثيل دون زيادة عدد المراجع الخاص به. weakيجب أن تكون المراجع متغيرات اختيارية، لأنها قابلة للتغيير nil. ^{[ 107 ]} محاولة الوصول إلى unownedقيمة تم تحريرها بالفعل تؤدي إلى خطأ وقت التشغيل.

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

فئة الشخص {let name : Stringweak var home : Home ? // تم تعريفها كمرجع ضعيف لكسر حلقة المراجع. المراجع الضعيفة لا تزيد عدد المراجع للمثيل الذي تشير إليه.تهيئة ( الاسم : سلسلة نصية ) {اسم الذات = الاسم​}deinit { print ( "تم إلغاء تهيئة \( name ) " ) }}فئة الصفحة الرئيسية {let address : Stringvar owner : Person ?دالة التهيئة ( العنوان : سلسلة نصية ، المالك : شخص ؟) {العنوان الذاتي = العنوان​المالك الذاتي = المالك​}deinit { print ( "تم إلغاء تهيئة \( address ) " ) }}var stacy : Person ? = Person ( name : "Stacy" )var house21b : Home ? = Home ( address : "21b Baker Street" , owner : stacy )stacy ?. home = house21b // stacy و house42b يشيران الآن إلى بعضهما البعض.stacy = nil // أصبح عدد المراجع لـ stacy الآن 1، لأن house21b لا يزال يحتفظ بمرجع إليه.house21b = nil // ينخفض ​​عدد المراجع الخاصة بـ house21b إلى 0، مما يؤدي بدوره إلى انخفاض عدد المراجع الخاصة بـ stacy إلى 0 لأن house21b كانت آخر حالة تحتفظ بمرجع قوي إلى stacy.// يطبع:// تم إلغاء تهيئة 21ب شارع بيكر// تم إلغاء تهيئة ستايسي

يُعدّ نظام Swift عنصرًا أساسيًا نظرًا لقدرته على تصحيح الأخطاء بسلاسة وتشغيله ضمن بيئة التطوير، باستخدام حلقة قراءة-تقييم-طباعة (REPL)، مما يمنحه خصائص تفاعلية أقرب إلى قدرات البرمجة النصية في Python منها إلى لغات برمجة الأنظمة التقليدية . وقد تم تعزيز REPL بشكل أكبر من خلال بيئات تجريبية ( Playgrounds ) ، وهي واجهات تفاعلية تعمل ضمن بيئة Xcode أو تطبيق Playgrounds، وتستجيب لتغييرات التعليمات البرمجية أو مصحح الأخطاء بشكل فوري. ^{[ 108 ]} تتيح بيئات Playgrounds للمبرمجين إضافة تعليمات Swift البرمجية مع توثيق Markdown. ويمكن للمبرمجين تتبع تنفيذ التعليمات البرمجية وإضافة نقاط توقف باستخدام LLDB إما في وحدة تحكم أو بيئة تطوير متكاملة (IDE) مثل Xcode.