I Swift kan protokoll och protokollutvidgningar hjälpa utvecklare att skriva flexibel, återanvändbar och underhållbar kod. Protokoll, som definierar specifika krav för typer, är en central funktion i Swift och ger oss möjligheten att bygga enhetliga gränssnitt för olika datatyper. När man arbetar med protokoll i Swift, finns det flera viktiga aspekter att förstå, såsom jämförelse av instanser, hashring och användning av generics.

För att förstå detta bättre, låt oss ta ett exempel. Tänk dig att vi vill skapa en enkel struktur som lagrar namn, där varje instans av typen "Name" innehåller ett förnamn och ett efternamn. Här är en enkel definition av denna struktur:

swift
struct Name {
    var firstName: String
    var lastName: String
}

Nu skapar vi tre instanser av denna struktur:

swift
let name1 = Name(firstName: "Jon", lastName: "Hoffman")
let name2 = Name(firstName: "John", lastName: "Hoffman")
let name3 = Name(firstName: "Jon", lastName: "Hoffman")

Om vi försöker jämföra dessa instanser med hjälp av ==, som i följande kod, kommer vi att stöta på ett kompilatorfel eftersom strukturen Name inte är kompatibel med protokollet Equatable:

swift
name1 == name2
name1 == name3

För att kunna använda jämförelseoperatorer med instanser av Name, måste denna struktur konforma till protokollet Equatable. I normala fall skulle vi definiera denna överensstämmelse och tillhandahålla den nödvändiga funktionaliteten, som vi gör här:

swift
struct Name: Equatable {
    var firstName = ""
    var lastName = ""
    
    static func == (lhs: Name, rhs: Name) -> Bool {
        return lhs.firstName == rhs.firstName && lhs.lastName == rhs.lastName
    }
}

Men Swift kan automatiskt tillhandahålla protokollöverensstämmelse för Equatable, Hashable och Comparable. Det innebär att vi inte behöver skriva hela funktionen för att jämföra värden. Det räcker att ange att strukturen konformerar till Equatable, och Swift kommer att generera den nödvändiga koden under kompilering. Det här är vad vi gör här:

swift
struct Name: Equatable {
    var firstName = ""
    var lastName = ""
}

Genom denna automatiserade process kan vi jämföra instanser av Name utan att behöva skriva ytterligare kod. Detta sparar både tid och minskar kodduplicering.

Detta är ett exempel på hur protokoll och protokollutvidgningar kan effektivisera programmeringen i Swift. Protokoll utgör en nyckelkomponent för att säkerställa att kod är modulär, återanvändbar och lätt att underhålla. Ett annat exempel på användbarhet är när man arbetar med protokoll som Hashable och Comparable, där dessa protokoll kan generera de nödvändiga funktionerna för att jämföra objekt och skapa hashvärden utan att behöva skriva egen kod. Genom att använda dessa automatiserade lösningar kan utvecklare snabbt och effektivt hantera vanligt förekommande uppgifter, vilket gör koden mer läsbar och underhållbar.

Förutom de funktioner som genereras automatiskt, är det också viktigt att förstå hur protokollutvidgningar fungerar. Protokollutvidgningar kan ge standardimplementationer för metoder och egenskaper som olika typer som konformerar till protokollet kan använda. Detta minskar behovet av att skriva samma kod om och om igen för varje typ som använder protokollet.

När det gäller prestanda är det också viktigt att vara medveten om effekten av att använda protokoll och protokollutvidgningar. Eftersom Swift automatiskt genererar implementationer för protokoll som Equatable, Comparable och Hashable, kan dessa metoder optimeras vid kompilering, vilket förbättrar prestandan i applikationer där stora mängder objekt måste jämföras eller hashas.

En annan kraftfull funktion i Swift är användningen av generics, som gör det möjligt att skapa flexibla och återanvändbara funktioner och typer som fungerar med flera konkreta datatyper. Med generics kan vi skriva kod som inte är bundet till en specifik typ, utan kan anpassas för olika typer av data när det behövs. Det gör det möjligt att minska kodduplicering och skapa lösningar som kan användas i ett större antal sammanhang.

Tänk till exempel på en funktion som byter värden mellan två variabler. Utan generics skulle vi behöva skriva olika funktioner för att byta mellan Int, Double eller String. Detta leder snabbt till upprepad kod, vilket är både ineffektivt och svårt att underhålla. Med generics kan vi skapa en enda funktion som fungerar med alla datatyper:

swift
func swapGeneric<T>(a: inout T, b: inout T) {
    let tmp = a
    a = b
    b = tmp
}

Här är T en generisk platshållartyp som kommer att ersättas med den specifika typen när funktionen anropas. På så sätt kan vi använda denna funktion för att byta värden mellan olika typer utan att behöva duplicera kod för varje typ.

Med generics kan vi skapa funktioner och typer som är flexibla och kan anpassas för att hantera en mängd olika datatyper, vilket gör Swift till ett mycket kraftfullt språk för att skriva effektiv och underhållbar kod.

Det är också viktigt att förstå hur generics inte bara gör koden mer flexibel utan också säkerställer typ-säkerhet. Genom att använda generics kan vi bevara Swift's typkontroll och ändå skriva kod som är återanvändbar och skalbar för en rad olika scenarier. Detta gör generics till en oumbärlig funktion för alla som vill skriva kod som är både robust och mångsidig.

Hur man använder Swift Testing för att effektivt skriva tester i Xcode

För att komma igång med Swift Testing, behöver vi först lägga till Swift Testing-paketet som ett beroende i vårt projekt. Det görs genom att lägga till följande kod i din Package.swift-fil. Om du redan har andra beroenden, ska du endast lägga till .package-raden i den befintliga dependencies-blocket för att undvika att skapa ett nytt block:

swift
dependencies: [
   .package(url: "https://github.com/swiftlang/swift-testing.git", branch: "main"),
],

Sedan lägger vi till ett testmål i targets-blocket med följande kod:

swift
testTarget(
   name: "MyProjectTests",
   dependencies: [
     "MyProject",
     .product(name: "Testing", package: "swift-testing"),
   ]
)

När vi har lagt till testmålen i projektet kan vi börja utforska Swift Testing mer i detalj. För att kunna använda Swift Testing effektivt finns det flera grundläggande byggstenar som vi måste förstå. Dessa komponenter bildar grunden för Swift Testing och gör det möjligt för oss att skriva, organisera och köra våra tester på ett effektivt sätt.

En av de viktigaste byggstenarna är @Test-attributet.

Att deklarera en @Test-funktion

@Test-attributet är en central komponent i Swift Testing, som används för att markera en funktion som ett test. Det gör att Xcode kan känna igen och visa en kör-knapp bredvid funktionen. Denna funktion säkerställer att testfunktioner enkelt kan identifieras och köras inom Xcode-miljön. Testfunktioner som har @Test kan vara funktioner eller metoder inom en typ, vilket ger flexibilitet när vi organiserar och strukturerar våra tester. Dessa testfunktioner kan också märkas som async eller throws, vilket möjliggör asynkrona operationer och felhantering inom testerna.

Dessutom kan testfunktionerna isoleras till en global aktör om det behövs för att säkerställa trådsäker körning. @Test-attributet stöder även egenskaper för att specificera ytterligare information på ett per-test eller per-testsvit basis, vilket gör det möjligt att finjustera och anpassa testbeteenden och miljöer. Det stödjer även parameteriserad testning genom att acceptera argument, vilket gör att testfunktionen kan köras upprepade gånger för varje argument. Detta förenklar processen att testa flera ingångsscenarier och säkerställer fullständig testtäckning.

Förväntningar med #expect-makrot

#expect-makrot i Swift Testing används för att uttrycka förväntningar och asserter i testfall. Det är den primära metoden för att validera villkor, vilket förenklar skrivandet av tester genom att ersätta de många assertionsfunktionerna som finns inom XCTest. Detta makro gör det också möjligt för oss att uttrycka förväntningar som booleska uttryck, vilket ger större flexibilitet och enkelhet jämfört med andra testningsramverk. En annan fördel är makrets förmåga att fånga upp deluttryckens värden, vilket ger fullständig diagnostisk information när ett test misslyckas.

#expect-makrot kan användas för olika typer av asserter, inklusive likhetskontroller, felhantering och anpassade villkor. Det stöder också olika former av felhantering, som att verifiera att koden inte kastar ett fel eller att den kastar ett specifikt fel.

swift
@Test func validExpectation() async throws {
    #expect(1 == 1)
}

När en testfunktion är definierad med ett #expect-makro inom Xcode-miljön kan vi klicka på diamanten bredvid funktionen för att köra testerna. När testerna körs kommer antingen en grön bock eller ett rött x att visas i diamanten, vilket indikerar om testet passerade eller misslyckades.

Användning av #require-makrot

#require-makrot i Swift Testing används främst för att "unwrap" valfria värden och säkerställa att de inte är nil inom testet. När detta makro används och ett valfritt värde är nil, kommer testet omedelbart att misslyckas. Testfunktioner som använder #require måste markeras som "throwing", och try-nyckelordet måste föregå makrot. Detta gör att makrot kan kasta ett fel om det valfria värdet är nil.

swift
let one: Int? = 10
let two: String? = nil
let willSucceed = try #require(one)
let willFail = try #require(two)

I exemplet ovan kommer #require(one) att passera och "unwrap" värdet eftersom det inte är nil, medan #require(two) kommer att misslyckas eftersom two är nil, vilket leder till att testet avslutas omedelbart. Detta makro hjälper oss att skriva mer precisa tester genom att säkerställa att de villkor som är nödvändiga för att testet ska fortsätta faktiskt är uppfyllda.

Bekräftelser med confirmation(expectedCount:)

Swift Testing introducerade i version 6.1 en kraftfull funktion för att bekräfta att ett visst antal objekt producerades eller bearbetades i testfallet. Funktionen confirmation(expectedCount:) är särskilt användbar för att verifiera att ett förväntat antal objekt finns när en operation har utförts. Istället för att manuellt kontrollera antal eller skriva egna felmeddelanden gör Swift det möjligt för oss att uttrycka våra förväntningar tydligt och på ett lättläst sätt.

Om antalet bekräftelser inte stämmer överens med det förväntade antalet, misslyckas testet och ger ett exakt felmeddelande om vad som förväntades och vad som faktiskt observerades.

swift
@Test func testRandomArrayCountInRange() async throws {
    let range = 5...10
    let count = Int.random(in: 0...15)
    let values = Array(repeating: "Item", count: count)
    await confirmation(expectedCount: range) { confirm in
        for _ in values {
            confirm()
        }
    }
}

I detta exempel definieras ett giltigt intervall (5...10) för hur många objekt som ska finnas i arrayen. Sedan genereras ett slumpmässigt antal objekt och en array skapas med detta antal. För varje objekt i arrayen anropas confirm() exakt en gång per objekt. Om antalet bekräftelser är utanför det angivna intervallet, misslyckas testet med ett meddelande om vad som förväntades och vad som observerades.

Exit-tester

En av de största utmaningarna med Swift Testing har varit oförmågan att verifiera kod som orsakar allvarliga fel, sådana som stoppar hela processen, till exempel preconditionFailure eller fatalError. Med Swift 6.2 åtgärdas denna begränsning genom exit-tester, introducerade i ST-0008. Denna funktion gör det möjligt att på ett säkert och förutsägbart sätt testa kod som förväntas krascha genom att köra den i en separat subprocess och kontrollera om processen avslutades som förväntat.

Genom att testa kod som leder till krasch eller tvingad avslutning kan vi försäkra oss om att felhantering och säkerhetskontroller fungerar som de ska i alla scenarier.

Hur Swift 5.0 och ABI-stabilitet Förändrade Utvecklingslandskapet

Swift 5.0, som lanserades 2019, markerade en viktig vändpunkt för Apples programmeringsspråk. Den stabila versionen av applikationsbinärgränssnittet (ABI) som introducerades vid denna tidpunkt löste en långvarig utmaning som många utvecklare tidigare stått inför: binär kompatibilitet. Detta innebär att Swift-kod som kompilerats med en äldre version av kompilatorn nu kan interagera med kod som är kompilerad med en nyare version, utan att stöta på kompatibilitetsproblem. Denna förbättring säkerställde inte bara att applikationerna fungerade felfritt på lång sikt utan också att de förblev stabila och framtidssäkrade när Swift utvecklades vidare.

För utvecklare innebar detta en helt ny nivå av säkerhet och förtroende när de distribuerade sina förkompilerade bibliotek. De visste att koden skulle vara kompatibel med framtida versioner av Swift, vilket var en viktig förutsättning för långsiktig hållbarhet inom programmering och utveckling av applikationer. Stabiliteten hos ABI:n gav Swift en starkare position som ett mångsidigt språk, särskilt när det gäller att skapa applikationer för flera plattformar inom Apples ekosystem.

Den här förbättrade binära kompatibiliteten möjliggjorde för utvecklare att använda Swift för att skapa kod som fungerade på alla Apples plattformar – från iOS och macOS till watchOS, visionOS och tvOS. Den nya förmågan att skriva kod en gång och distribuera den över olika enheter och operativsystem underlättade utvecklingsprocessen, samtidigt som det gjorde det möjligt att bygga högpresterande och stabila applikationer som fungerade på ett stort antal enheter.

När man ser tillbaka på utvecklingen av Swift fram till version 5.0, ser man tydligt hur viktigt detta ögonblick var för språket. Apple hade etablerat en ny standard för hur teknologi och programmeringsspråk kan utvecklas med långsiktig hållbarhet i åtanke. Swift 5.0 och ABI-stabiliteten var inte bara en teknisk prestation; de representerade också en ny modell för hur teknikföretag kan samarbeta med sina utvecklarsamhällen, vilket hade stor inverkan på den globala programmeringsvärlden.

Med varje ny version av Swift har språket genomgått en noggrant planerad och väl genomtänkt utveckling. Från Swift 1.0, som erbjöd en ren och kraftfull syntax, till Swift 5.0 och den stabila ABI:n, har Swift alltid strävat efter att göra programmering både snabbare och säkrare. Genom att introducera funktioner som optionals för att göra koden säkrare och closures för mer interaktiv programmering har Apple också förenklat arbetsflödet för utvecklare och säkerställt att språket var anpassat för framtidens behov.

I och med introduktionen av Swift 5.0 och ABI-stabiliteten började även utvecklare kunna förlita sig på att deras arbete skulle vara hållbart över flera år framöver, vilket stärkte Swift som ett verktyg för professionella utvecklare över hela världen. Det gav dem också möjlighet att distribuera sina applikationer på ett sätt som tidigare varit omöjligt, och som har fortsatt att forma och förändra sättet på vilket programvara utvecklas.

I de följande åren, med varje ny version som släpptes, har Apple fortsatt att förbättra språket och lägga till nya funktioner för att göra det mer kraftfullt och användarvänligt. Swift 5.x, som har varit i bruk i över fem år med tiotalet mindre uppdateringar, har blivit en stabil grund för alla som bygger programvara inom Apples ekosystem.

Med version 6.0, som förväntades bli släppt i september 2024, förberedde Apple sig för att göra ytterligare framsteg, bland annat genom att införa möjligheten för "cross-compilation". Detta gör att utvecklare kan kompilera kod på macOS och distribuera den till Linux-plattformar, vilket utökar räckvidden för applikationerna och förbättrar mångsidigheten i användningen av Swift.

De senaste förbättringarna inom Swift 6.0, som förbättrad hantering av samtidiga uppgifter och striktare regler för koncurrency, säkerställer också att utvecklare kan skriva snabbare, mer pålitlig kod utan att oroa sig för potentiella data race-problem. Dessa nya funktioner, tillsammans med införandet av Typed Throws för bättre felhantering, gör att Swift fortsätter att vara ett språk som inte bara är kraftfullt utan också säkerställer en hög nivå av kodkvalitet och stabilitet.

För att förstå dessa utvecklingssteg fullt ut är det avgörande att inse att varje iteration av Swift inte bara har handlat om att introducera nya funktioner, utan också om att göra dessa funktioner både användbara och tillförlitliga för utvecklare. Den långsiktiga hållbarheten som ABI-stabiliteten ger, och de kontinuerliga förbättringarna i språket, ger utvecklare en stabil grund att bygga på – vilket gör Swift till ett framtidssäkert val för att skapa applikationer i Apples ekosystem.

Hur Swift Utnyttjar Protokollorienterad Design för Flexibilitet och Effektivitet

Swift uppmuntrar inte bara till ett protokollorienterat tillvägagångssätt för vår kodbas utan det är även själva fundamentet för hur Swift-standardbiblioteket är utformat. När man undersöker dokumentationen för Swift-standardbiblioteket, som finns på Apple Developer, blir det snabbt uppenbart att biblioteket har utvecklats med en protokollorienterad design. Ett exempel på detta blir tydligt när man granskar dokumentationen för heltalstypen, som följer 34 protokoll, bland annat:

  • BinaryInteger

  • Comparable

  • Decodable

  • Encodable

  • EntityIdentifierConvertible

  • Equatable

  • Numeric

  • SignedInteger

  • SignedNumeric

Många av standardbibliotekets typer är byggda kring protokoll, vilket ger hög flexibilitet och interoperabilitet. Denna designfilosofi är tydlig genom det omfattande användandet av protokoll som Equatable, Comparable och Collection, som definierar gemensamma gränssnitt och beteenden som flera typer kan anta. Genom att förstå och använda ett protokollorienterat tillvägagångssätt kan utvecklare maximera användningen av Swifts kapabiliteter.

Swift är inte bara en objektorienterad språkstruktur, utan också ett protokollorienterat språk där protokoll och protokollutökningar spelar en central roll, till skillnad från traditionell objektorienterad programmering som fokuserar på klasser och klasshierarkier. Nyckeltekniker inom protokollorienterad programmering (POP) som protokollinhet, protokollkomposition och protokollutökningar gör det möjligt för Swift att leverera en flexibel och kraftfull upplevelse.

Protokollinhet tillåter ett protokoll att anta krav från ett annat protokoll, vilket möjliggör skapandet av mer specifika och fokuserade protokoll. Protokollkomposition ger typer möjlighet att följa flera protokoll, vilket skapar stor flexibilitet och gör det möjligt att konstruera komplex funktionalitet från enklare komponenter. Protokollutökningar tillhandahåller standardimplementeringar för metoder och egenskaper inom protokoll, vilket gör att konformerande typer kan ta del av funktionalitet utan redundant kod.

En central aspekt av Swift är att det standardbibliotek som tillhandahålls utvecklare är utvecklat kring dessa principer. Genom att undersöka bibliotekets dokumentation kan man se att majoriteten av typerna är byggda med protokoll, vilket säkerställer både flexibilitet och interoperabilitet. Designfilosofin bakom protokoll som Equatable, Comparable och Collection understryker styrkan och effektiviteten i en protokollorienterad design och uppmuntrar utvecklare att använda dessa principer i sin egen kodbas.

Det är viktigt att förstå att detta tillvägagångssätt inte bara främjar återanvändbar kod, utan också gör det möjligt att bygga robusta system där komponenter kan interagera utan att vara djupt beroende av varandra. Denna typ av lös design är särskilt kraftfull när man arbetar med stora kodbaser, där underhåll och vidareutveckling kan ske utan att hela systemet påverkas negativt.

Vidare gör användningen av protokoll i Swift det möjligt att skapa system som är både flexibla och lättanpassade. Eftersom protokoll inte binder oss till specifika implementationer eller hierarkier kan vi enkelt skapa olika versioner av samma koncept beroende på applikationens behov, vilket är en fördel som många andra programmeringsspråk inte har i samma utsträckning.

För att helt förstå potentialen i Swifts protokollorienterade design är det avgörande att inte bara använda protokollens gränssnitt utan också att utnyttja deras fulla kapacitet via protokollkomposition och utökningar. Detta gör det möjligt att skapa kod som är både kraftfull och modulär, vilket underlättar både testning och vidareutveckling.

I nästa kapitel kommer vi att utforska hur Swift kan användas som ett funktionellt programmeringsspråk och hur det kompletterar de objektorienterade och protokollorienterade aspekterna av språket. Det är viktigt att komma ihåg att Swift inte begränsar sig till en enstaka programmeringsparadigm, utan erbjuder en mångsidig plattform där olika programmeringsstilar kan integreras effektivt.

Comment enseigner des tours à votre chien : techniques et astuces pour des performances époustouflantes
Comment créer des salades sans cuisson : un mélange de saveurs et de textures
Comment la coopération avec la justice influence-t-elle la peine dans les affaires criminelles fédérales américaines ?