რომელი პროგრამირების პრინციპი იძლევა გენერიკების გამოყენების შესაძლებლობას?

პოლიმორფიზმი ქვესახეობაში.

Swift-ში გენერიკები ახორციელებს პარამეტრიულ პოლიმორფიზმს, რაც საშუალებას აძლევს დაწეროთ კოდი, რომელიც მუშაობს სხვადასხვა ტიპებთან, წინასწარ არ იცით მათი, მაგრამ საჭიროა, რომ ამ ტიპებმა შეასრულონ გარკვეული შეზღუდვები (მაგალითად, პროტოკოლები).

გენერიკების გამოყენების მაგალითი:

// გენერიკ-ფუნქციის განსაზღვრა, რომელიც იღებს ორი პარამეტრს ერთ ტიპის T,
// სადაც T ტიპი უნდა შეესაბამებოდეს Equatable პროტოკოლს.
func areEqual<T: Equatable>(_ a: T, _ b: T) -> Bool {
    return a == b
}

// გენერიკ-ფუნქციის გამოყენება Int-თან
let intResult = areEqual(5, 5) // true

// გენერიკ-ფუნქციის გამოყენება String-თან
let stringResult = areEqual("hello", "world") // false

გენერიკ-სტრუქტურის (სია) მაგალითი:

// გენერიკ-სტრუქტურის "Stack" განსაზღვრა, რომელიც შეუძლია შეინახოს ნებისმიერი ტიპის T ელემენტები.
struct Stack<T> {
    private var elements: [T] = []

    mutating func push(_ element: T) {
        elements.append(element)
    }

    mutating func pop() -> T? {
        return elements.popLast()
    }
}

// გენერიკ-სტრუქტურის გამოყენება Int-თან
var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
let poppedInt = intStack.pop() // 2

// გენერიკ-სტრუქტურის გამოყენება String-თან
var stringStack = Stack<String>()
stringStack.push("A")
stringStack.push("B")
let poppedString = stringStack.pop() // "B"

გენერიკების გამოყენების უპირატესობები:

• ტიპების უსაფრთხოება: კომპილატორი ამოწმებს ტიპებს კომპილაციის დროს, ამცირებს runtime-ის შეცდომების ალბათობას.
• კოდის გადამეორება: ერთი და იგივე კოდი მუშაობს სხვადასხვა ტიპებთან.
• პროდუქტიულობა: არ არის საჭირო ტიპების გარდაქმნა (type casting) შესრულების დროს.
• აბსტრაქცია: საშუალებას აძლევს აბსტრაგციონირებას კონკრეტული მონაცემთა ტიპებისგან.