Bli en iOS-utvikler: Hvordan begynne å utvikle for iPad og iPhone

Innhold

Må jeg vite Swift?
Konfigurer Apples Xcode IDE
Komme i gang: Lag et nytt Xcode-prosjekt
Utviklingsteam kreves?
Forstå Apples Xcode IDE
AppleDelegate: Undersøker Swift-kildefilen
1. Opprett et inngangspunkt
2. Definer AppDelegate
3. Definer en vinduegenskap
4. Assorterte Stub-implementeringer
Testing av prosjektet ditt: Kjør iOS Simulator
Opprette et brukergrensesnitt med grensesnittbyggeren
Få tilgang til iOS-objektbiblioteket
Tilpasse objekter med attributtsinspektøren
Forhåndsvis brukergrensesnittet
Koble brukergrensesnittet til kildekoden
Lage en handlingsmetode
1. Angi at denne metoden er en handling
2. Erklær metoden
3. Definer noen parametere
Sjekk tilkoblingen
Oppretter en varselsdialog
1. erklære en konstant
2. Angi innholdet
3. Angi stilen
4. Legg til en handling
5. Vis varselet
Tester den ferdige iOS-appen din
Innpakking

Android er kanskje et av de mest populære operativsystemene i verden, men det er langt fra det eneste mobile operativsystemet!

Hvis du vil at mobilapplikasjonen din skal nå et bredest mulig publikum, må du målrette deg mot flere plattformer. Mens du kunne velger et plattformutviklingsverktøy som Flutter, du kan også lage flere kodebaser, som lar deg levere en brukeropplevelse som er designet og skreddersydd for hver mobilplattform.

Kanskje du vil gi ut den nyeste mobilappen din på Android og iOS, kanskje du vurderer å hoppe skipet til Apple, eller kanskje du bare er nysgjerrig på å se hvordan utvikling for iOS sammenlignes med å utvikle for Android. Uansett motivasjon, i denne artikkelen vil jeg vise deg hvordan du kan begynne å utvikle for iOS, ved å lage en enkel app for iPad og iPhone.

Underveis skal jeg gi en introduksjon til kjernekonseptene til Apples Swift-programmeringsspråk, lede deg gjennom de viktigste områdene i det Xcode integrerte utviklingsmiljøet, og vise deg hvordan du tester prosjektene dine i iOS Simulator - bare i tilfelle du har ikke forpliktet meg til å kjøpe en iPad eller iPhone ennå!

Dette er hva du trenger å vite for å begynne å utvikle for iOS.

Må jeg vite Swift?

Når du begynner å utvikle for iOS, vil du vanligvis velge mellom to programmeringsspråk: Objekt-C eller Swift. Lansert i 2014, er Swift det mer moderne språket, pluss at Apple ser ut til å skyve Swift over Objekt-C for iOS-utvikling, så jeg vil bruke Swift gjennom hele denne opplæringen.

Hvis du er en erfaren Swift-proff, har du et forsprang. Men selv om du aldri har gjort det sett en enkelt linje med Swift før, vil du fremdeles kunne følge med, og mot slutten av denne artikkelen vil du ha opprettet en fungerende iOS-applikasjon, skrevet helt i Swift.

Når vi bygger iOS-appen min, vil jeg forklare kjernekonseptene til dette programmeringsspråket, så du får en grunnleggende oversikt over Swift og vil forstå nøyaktig hva som skjer i hver kodelinje, selv om du er helt ny på Swift.

Dessverre har du ikke behersket et helt nytt programmeringsspråk når du kommer til bunnen av denne siden, men hvis du bestemmer deg for å satse på iOS-utvikling, vil jeg anbefale å sjekke ut Swift Playgrounds-appen. Denne applikasjonen inneholder Learn To Code-øvelser, presentert som interaktive puslespill som hjelper deg med å gjøre deg kjent med de Swift-nødvendighetene du trenger, for å fortsette å utforske iOS-utviklingen.

Konfigurer Apples Xcode IDE

For å utvikle for iPhone og iPad, trenger du en Mac som kjører macOS 10.11.5 eller nyere. Hvis du er usikker på hvilken versjon av macOS du kjører for øyeblikket, så:

Velg "Apple" -logoen på Mac-menylinjen.
Velg "Om denne Macen."
Forsikre deg om at "Oversikt" -fanen er valgt; din versjon av macOS skal vises i dette vinduet.

Du trenger også Xcode, som er Apples integrerte utviklingsmiljø (IDE). Xcode har alle verktøyene og funksjonene som kreves for å designe, utvikle og feilsøke applikasjoner for macOS, watchOS, tvOS - og iOS.

Slik laster du ned den nyeste versjonen av Xcode:

Start App Store på Mac-en.
I feltet "Søk" skriver du inn "Xcode."
Når Xcode-applikasjonen vises, velger du "Få" etterfulgt av "Installer app."
Når du blir bedt om det, oppgir du Apple-ID og passord. Hvis du ikke har en Apple-ID, kan du opprette en gratis. Xcode vil nå lastes ned til Mac-en “Applications” -mappen.
Når Xcode er ferdig med nedlastingen, kan du starte den. Les vilkårene, og hvis du er fornøyd med å fortsette, klikker du på "Godta".
Hvis Xcode ber deg laste ned litt ekstra programvare, må du følge instruksjonene på skjermen for å laste ned disse manglende komponentene.

Komme i gang: Lag et nytt Xcode-prosjekt

I likhet med Android Studio, kommer Xcode med en rekke maler for vanlige kategorier av iOS-applikasjoner, for eksempel tabulatorbasert navigasjon og spill. Disse malene inkluderer kjeleplate-kode og filer som kan hjelpe til å starte iOS-prosjektene dine. I denne artikkelen bruker vi en av disse ferdige maler.

Slik oppretter du et nytt Xcode-prosjekt:

Start Xcode IDE hvis du ikke allerede har gjort det.
Etter noen få øyeblikk vises "Velkommen til Xcode" -skjermen. velg "Opprett et nytt Xcode-prosjekt." Hvis velkomstskjermen ikke vises, velger du "Fil> Ny> Prosjekt" fra Xcode-menylinjen.
I vinduet "Velg en mal for det nye prosjektet", sørg for at fanen "iOS" er valgt.
Velg "Enkelvisning-app" -malen, og klikk deretter "Neste."
I "Produktnavn" skriver du inn "HelloWorld." Xcode vil bruke dette til å navngi prosjektet og applikasjonen din.
Angi eventuelt et valgfritt “Organisasjonsnavn.”
Skriv inn din "Organisasjonsidentifikator." Hvis du ikke har en identifikator, kan du bruke "com.example." Merk at "Bundle Identifier" blir generert automatisk basert på produktnavnet og organisasjonsidentifikatoren din, så du ikke trenger å bekymre deg for dette.
Åpne rullegardinmenyen “Språk”, og velg “Swift”.
Finn avmerkingsboksen Bruk kjernedata, og sørg for at den er det ikke valgt.
Merk av for "Inkluder enhetstester".
Finn avmerkingsboksen "Inkluder UI-tester", og sørg for at den er det ikke valgt.
Klikk "Neste."
I den påfølgende dialogen velger du stedet der du vil lagre prosjektet, og klikker deretter "Opprett."

Xcode vil nå laste inn prosjektet ditt i arbeidsområdet.

Utviklingsteam kreves?

På dette tidspunktet kan Xcode vise følgende feil "Signering for HelloWorld krever et utviklingsteam."

Før du kan kjøre prosjektet ditt på en fysisk iOS-enhet, må du sette opp et gyldig team og signere søknaden din. Siden vi bare eksperimenterer med iOS, trenger du ikke å fullføre signeringsprosessen nå, men du må signere applikasjonen din før den kan kjøres på en fysisk enhet eller få tilgang til visse tjenester, for eksempel Game Center eller In-App kjøp.

Forstå Apples Xcode IDE

Xcodes arbeidsområde er der du vil skrive all appens kildekode, designe og bygge brukergrensesnittet (UI), og lage alle tilleggsfiler og ressurser som til slutt vil komme sammen for å danne den fullførte iOS-applikasjonen.

Xcode er fullpakket med funksjoner, men som en nykommer i utviklingen av iOS er det noen få områder du trenger å vite om:

(1) Navigasjonsområde. Dette området gir rask og enkel tilgang til alle de forskjellige filene og ressursene som utgjør prosjektet ditt. Du kan undersøke innholdet i en fil ved å velge den i navigasjonsområdet. Merk at du bare trenger å gjøre det plukke ut den aktuelle filen; dobbeltklikker du på en fil vil den startes i et nytt, eksternt vindu.
(2) Editor-området. Avhengig av filen du velger i navigasjonsområdet, vil Xcode vise forskjellige grensesnitt i redigeringsområdet. Vanligvis vil du bruke Editor-området til å skrive programmets kildekode og bygge UI-en.
Bruksareal. Dette området er delt inn i to seksjoner. Øverst i verktøyområdet (3) viser inspektørruten, der du kan vise informasjon om elementet du har valgt i navigasjons- eller redigeringsområdet, og redigere attributtene. Bunnen av verktøyområdet (4) viser bibliotek-ruten, som gir tilgang til noen ferdige brukergrensesnittelementer, kodebiter og andre ressurser.

AppleDelegate: Undersøker Swift-kildefilen

Single View App-malen inneholder alle Swift-koder og ressurser som kreves for å lage en enkel, men fungerende iOS-applikasjon.

Du kan se alle disse automatisk genererte filene og ressursene i navigasjonsområdet (mot venstre side av Xcode-arbeidsområdet).

Hvis navigasjonsområdet ikke er synlig, kan du koble det ut av å gjemme seg ved å velge "Vis> Navigatorer> Vis prosjektnavigator" fra Xcode-menylinjen.

Simple View Application-malen genererer automatisk flere filer, men la oss begynne med å undersøke “AppleDelegate.swift.” Velg denne filen i navigasjonsområdet, og redigeringsområdet skal oppdateres for å vise innholdet i filen.

importer UIKit @UIApplicationHovedklasse AppDelegate: UIResponder, UIApplicationDelegate {var vindu: UIWindow? // I Swift erklærer du en metode ved å bruke søkeordet "func" // func-applikasjon (_-applikasjon: UIApplication, didFinishLaunchingWithOptions launchOptions:?) -> Bool {return true} // Definer en "applikasjons" -parameter med typen "UIApplication" ”// func-applikasjonWillResignActive (_-applikasjon: UIApplication) {} func-applikasjonDidEnterBackground (_-applikasjon: UIA-applikasjon) {} func-applikasjonWillEnterForeground (_-applikasjon: UIApplication) {} func-applikasjonDidBecomeActive (_-applikasjon: UIApplication) {} func-applikasjon: ) {}}

La oss se nærmere på hva som skjer i denne filen:

1. Opprett et inngangspunkt

@UIApplicationMain-attributtet oppretter et inngangspunkt i appen din og en løpesløyfe, som er en hendelsesbehandlingssløyfe som lar deg planlegge arbeid og koordinere inngangshendelser i applikasjonen din.

@UIApplicationMain

2. Definer AppDelegate

AppDelegate.swift-filen definerer en AppleDelegate-klasse, som oppretter vinduet der appens innhold tegnes og gir et sted å svare på statlige overganger, for eksempel når appen din overgår til bakgrunnen eller føres i forgrunnen.

klasse AppDelegate: UIResponder, UIApplicationDelegate {

I koden ovenfor bruker vi også UIApplicationDelegate-protokollen, som definerer flere metoder du kan bruke for å konfigurere appen din, og håndtere forskjellige appnivå-hendelser.

3. Definer en vinduegenskap

AppDelegate-klassen inneholder en "vindu" -egenskap, som lagrer en referanse til applikasjonsvinduet. Denne egenskapen representerer roten til appens visningshierarki, og er der alt innholdet til appen din blir tegnet.

var vindu: UIWindow?

4. Assorterte Stub-implementeringer

AppDelegate-klassen inneholder også stub-implementeringer for flere delegatmetoder, for eksempel:

func-applikasjonDidEnterBackground (_-applikasjon: UIA-applikasjon) {

Disse metodene gjør det mulig for appobjektet å kommunisere med appens delegat. Hver gang applikasjonen endres, vil appobjektet ringe til den tilsvarende delegeringsmetoden, for eksempel når appen går over til bakgrunnen, vil den kalle ovennevnte applikasjonsDidEnterBackground-metode.

Hver av disse delegatmetodene har en standardatferd, men du kan definere tilpasset oppførsel ved å legge til din egen kode. For eksempel vil du vanligvis utvide applikasjonenDidEnterBackground-stubbimplementering ved å legge til kode for å frigi eventuelle delte ressurser. ApplicationDidEnterBackground-metoden er også der du bør lagre tilstrekkelig tilstandsinformasjon til å gjenopprette applikasjonen til sin nåværende tilstand, bare i tilfelle appen din blir avsluttet mens den er i bakgrunnen.

I tillegg til applicationDidEnterBackground, inneholder AppleDelegate.swift følgende metoder:

didFinishLaunchingWithOptions. Informerer delegaten om at lanseringsprosessen er nesten fullført og at søknaden din er nesten klar til å kjøres. Du bør bruke denne metoden for å fullføre initialiseringen av appen din og foreta eventuelle endelige justeringer, før applikasjonens brukergrensesnitt blir presentert for brukeren.
applicationWillResignActive. Forteller delegaten at søknaden din er i ferd med å gå fra en aktiv til en inaktiv tilstand. Denne metoden kan utløses av et midlertidig avbrudd, for eksempel en innkommende telefonsamtale, eller når applikasjonen begynner å gå over til en bakgrunnsstatus. Når appen din er i inaktiv tilstand, skal den utføre minimalt med arbeid, så du bør bruke applicationWillResignActive for å stoppe pågående oppgaver og deaktivere eventuelle tidtakere. Du bør også benytte anledningen til å lagre data som ikke er lagret, så de vil ikke gå tapt hvis brukeren velger å avslutte applikasjonen din mens den er i bakgrunnen.
applicationWillEnterForeground. I iOS 4.0 og nyere kalles denne metoden som en del av appens overgang fra bakgrunnen til en aktiv forgrunnen. Du bør bruke denne metoden for å angre alle endringer du gjorde da søknaden din kom inn i bakgrunnen.
applicationDidBecomeActive. Dette forteller delegaten at appen din har flyttet fra en inaktiv til en aktiv tilstand. Vanligvis oppstår dette når brukeren eller systemet lanserer applikasjonen din, men det kan også oppstå hvis brukeren velger å ignorere et avbrudd som flyttet appen din til en midlertidig inaktiv tilstand, for eksempel et innkommende telefonsamtale eller SMS. Du må bruke applicationDidBecomeActive-metoden for å starte eventuelle oppgaver som ble satt på pause mens applikasjonen var i inaktiv tilstand.
applicationWillTerminate. Denne metoden informerer delegaten om at søknaden din er i ferd med å avslutte. Du bør bruke denne metoden for å utføre nødvendig opprydding, for eksempel å lagre brukerdata eller frigjøre delte ressurser. Bare vær klar over at denne metoden har omtrent fem sekunder på å utføre oppgavene sine og returnere, og hvis den overskrider denne tidsgrensen, kan det hende at systemet bestemmer seg for å drepe prosessen helt.

Testing av prosjektet ditt: Kjør iOS Simulator

Siden vi brukte Single View App-malen, inneholder prosjektet vårt allerede nok kode til å kunne kjøres på iOS.

Du kan sette iOS-prosjektet ditt på prøve ved å bruke iOS Simulator som leveres ferdigpakket med Xcode. I likhet med Android Studios emulator, lar iOS Simulator deg teste hvordan appen din vil se ut og fungere på en rekke enheter, inkludert enheter med forskjellige skjermstørrelser og oppløsninger.

La oss kjøre vårt prosjekt i iOS Simulator:

Velg “Angi det aktive skjemaet” (der markøren er plassert i følgende skjermbilde).

Velg enheten du vil etterligne, for eksempel “iPhone 8,” “iPad Air 2” eller “iPhone X.” Simulatoren emulerer iPhone 8 Plus som standard.
Øverst til venstre på Xcode-verktøylinjen velger du "Kjør" -knappen (der markøren er plassert i følgende skjermbilde).

Hvis dette er første gang du tester en iOS-app, vil Xcode spørre om du vil aktivere utviklermodus. Utviklermodus lar Xcode få tilgang til visse feilsøkingsfunksjoner uten å be om passordet ditt hver eneste gang, så med mindre du har en spesifikk grunn til ikke å det, vil du vanligvis aktivere utviklermodus.

Når Xcode er ferdig med å bygge prosjektet ditt, vil iOS Simulator starte og laste inn appen din. I likhet med Android-emulatoren kan dette noen ganger være en treg prosess, så du kan trenge å være tålmodig (kanskje bruk dette som en mulighet til å skaffe deg en kaffe!)

Når søknaden din har lastet inn, vil du bli konfrontert med en vanlig hvit skjerm. Single View-appmalen kan være et fungerende iOS-program, men det er ikke akkurat en spennende applikasjon, så la oss legge til noen brukergrensesnittelementer.

Opprette et brukergrensesnitt med grensesnittbyggeren

Xcodes grensesnittbygger gir en visuell måte for deg å designe og bygge applikasjonens brukergrensesnitt på, på samme måte som hvordan Layout Editor fungerer i Android Studio.

Hvis du tar en titt på navigasjonsområdet, vil du se at malen for Single View-appen allerede har generert en "Main.storyboard" -fil, som er en Storyboard fil. Et storyboard er en visuell representasjon av appens brukergrensesnitt, som du kan redigere i grensesnittbyggeren.

Hvis du vil se på appens Storyboard, velger du Main.storyboard-filen i navigasjonsområdet. Interface Builder skal åpne automatisk og vise appens brukergrensesnitt, som for øyeblikket består av en enkelt skjerm.

Dette skjermbildet inneholder en enkelt visning, med en pil som peker mot venstre side av skjermen. Denne pilen representerer inngangspunktet til Storyboard, som er den første skjermen brukeren ser når de starter appen din.

Få tilgang til iOS-objektbiblioteket

Den enkleste måten å bygge brukergrensesnittet på er å bruke elementer fra Xcode-er Objektbibliotek. Dette biblioteket inneholder objekter som har en synlig tilstedeværelse på skjermen, for eksempel bildevisninger, navigasjonsbarer og brytere, og objekter som definerer oppførsel, men som ikke har en synlig tilstedeværelse, for eksempel bevegelsesgjenkjenning og containervisning.

Vi kommer til å lage en knapp som når du trykker på, viser et varsel. La oss starte med å ta en knapp fra Objektbiblioteket og legge den til i appen vår:

Mot nedre høyre hjørne av arbeidsområdet til Xcode, velg knappen "Vis objektbibliotek". Alternativt kan du velge "Vis> Verktøy> Vis objektbibliotek" fra Xcodes meny.

Objektbiblioteket skal nå vise en liste over alle de forskjellige elementene du kan legge til brukergrensesnittet. Bla gjennom denne listen for å se hvilke alternativer som er tilgjengelige.
Vi vil legge til en knapp, så skriv "knapp" i tekstfeltet "Filter", og velg deretter knappen når den vises i listen.
Dra knappobjektet på lerretet. Når du drar, vil et sett med horisontale og vertikale guider vises for å hjelpe deg med å plassere knappen. Når du er fornøyd med plasseringen, slipper du musen for å legge til knappen i brukergrensesnittet.

Tilpasse objekter med attributtsinspektøren

Deretter må vi legge til litt tekst på knappen. Du kan tilpasse objekter ved å bruke Xcodes Attributinspektør:

Velg "Vis> Verktøy> Vis attributterinspektør" fra Xcode-verktøylinjen; attributtinspektøren skal nå vises mot høyre side av Xcode-arbeidsområdet.

Velg knappobjektet på lerretet.
I Attributinspektøren finner du "Tittel" -delen og erstatter standard "Knapp" -teksten med en egen tekst.
Trykk på "Retur" -tasten på tastaturet, og Interface Builder oppdaterer knappen for å vise den nye teksten.

På dette tidspunktet kan det være lurt å eksperimentere med noen av knappens andre attributter, for eksempel kan du endre bakgrunnsfargen på knappen eller skriften som brukes til teksten.

Forhåndsvis brukergrensesnittet

Selv om du kunne teste applikasjonene dine ved å kjøre dem på iOS Simulator, er dette ikke alltid den enkleste måten å overvåke hvordan applikasjonen utformes.

Når du bygger brukergrensesnittet, kan du spare deg litt tid ved å forhåndsvise endringene i Xcodes "Forhåndsvisning" -vindu, som er en sekundærredigerer som vises som en del av det vanlige Xcode-arbeidsområdet.

Velg "Vis> Rediger> Vis assistentredigerer" fra Xcodes menylinje.
I menylinjen i Assistant Editor velger du "Automatisk."

Velg "Forhåndsvisning> Main.storyboard (Preview)." Assistant Editor vil nå vise en forhåndsvisning av appens brukergrensesnitt sammen med det vanlige Editor-området.
Hvis du vil forhåndsvise appens brukergrensesnitt i forskjellige retninger, blar du til bunnen av forhåndsvisningsvinduet og velger "Roter" -knappen.

Koble brukergrensesnittet til kildekoden

I iOS-utvikling er appkoden og brukergrensesnittet ditt adskilt, til det punktet hvor vi har opprettet en grunnleggende brukergrensesnitt uten å måtte skrive en eneste kodelinje. Imidlertid er det en ulempe med å holde kode og brukergrensesnitt atskilt: du må eksplisitt etablere et forhold mellom kildekoden og brukergrensesnittet ditt, ved å fordype deg i prosjektets klasser for UIViewController og ViewController.

UIViewController er en grunnleggende byggestein for iOS-applikasjoner, som er ansvarlig for å holde UI-elementer som knapper, skyvekontroller og tekstfelt. Som standard har UIViewController en tom visning, så vi må lage en tilpasset klasse som utvider UIViewController, kjent som en View Controller.

Hvis du åpner prosjektets "ViewController.swift" -fil, vil du se at enkeltvisningen-appmalen allerede har generert en View Controller for oss:

klasse ViewController: UIViewController {

For øyeblikket arver denne ViewController-klassen ganske enkelt all oppførselen definert av UIViewController, men du kan utvide og tilpasse denne standardoppførselen ved å overstyre metodene definert av UIViewController.For eksempel overstiger for øyeblikket ViewController.swift-filen ViewDidLoad () -metoden, men den gjør ikke gjøre alt annet enn å ringe UIViewControllers versjon av denne metoden:

overstyre func viewDidLoad () {super.viewDidLoad () // Gjør noe ekstra oppsett etter at du har lastet visningen //}

Selv om det er utenfor omfanget av denne opplæringen, kan du tilpasse View Controllers svar på denne hendelsen ved å legge til din egen kode til viewDidLoad () -metoden, for eksempel er det her du vanligvis vil utføre eventuelle ekstra oppsett som kreves av appen din.

Bak kulissene opprettet Single View App-malen automatisk en forbindelse mellom ViewController.swift-klassen og Main.storyboard. Under kjøring vil Storyboard opprette en forekomst av ViewController, og innholdet på Storyboard vises på skjermen.

Dette gir oss et forsprang, men vi må fortsatt koble de enkelte elementene i Storyboard, til ViewController.swift-filen vår, slik at kildekoden kan kommunisere med disse individuelle elementene.

Vår oppgave er å opprette en forbindelse mellom knappen vår og den aktuelle delen av kildekoden vår, slik at applikasjonen vår viser et varsel hver gang brukeren banker på knappen.

Lage en handlingsmetode

Å trykke på en knapp er en hendelse, så vi må lage en handlingsmetode, som er en kodeseksjon som definerer hvordan applikasjonen din skal svare på en bestemt hendelse.

Slik lager du en handlingsmetode:

Forsikre deg om at Main.storyboard-filen er valgt i navigasjonsområdet.
Åpne Xcode's Assistant Editor, ved å velge "Vis> Assistant Editor> Show Assistant Editor."
Klikk på “Automatic” i Editor-valglinjen og velg deretter “Automatic> ViewController.swift.”
På dette tidspunktet skal både ViewController.swift-filen og Storyboard være synlige på skjermen. I filen ViewController.swift, finn følgende linje og legg noen få linjer med tom plass under den:

klasse ViewController: UIViewController {

I storyboardet velger du knappen UI-elementet slik at det blir uthevet blått.
Kontroll-dra-knappen til det tomme området du nettopp opprettet i ViewController.swift-filen. En blå linje skal vises, som indikerer hvor handlingsmetoden skal opprettes.

Når du er fornøyd med metodens posisjon, slipper du knappen og en popup skal vises.
Åpne rullegardinmenyen "Tilkobling" i popup-vinduet og velg "Handling".
Deretter åpner du rullegardinmenyen "Hendelse" og velger "Trykk på innsiden", som er en hendelse som vil bli utløst når brukeren løfter fingeren inne i knappen.
Gi denne handlingen navnet "alertController."
Klikk på "Connect".

Xcode vil nå opprette følgende "alertController" -metode:

@IBAction func alertController (_ avsender: Enhver) {}

La oss dele nøyaktig hva som skjer her:

1. Angi at denne metoden er en handling

Attributtet “IBAction” eksponerer denne metoden for Interface Builder som en handling, som lar deg koble denne metoden til UI-objektene dine:

@IBAction

2. Erklær metoden

I Swift erklærer vi en metode som bruker "func" nøkkelordet, etterfulgt av navnet på metoden:

func alertControlle ()

3. Definer noen parametere

Deretter definerer vi noen valgfrie parametere i et sett med parenteser, som metoden vår deretter vil bruke som input.

Hvert sett med parametere skal ha et navn og en type, atskilt med en kolon (:).

func alertController (_ avsender: Enhver) {

Her aksepterer metoden en "avsender" -parameter, som refererer til objektet som var ansvarlig for å utløse handlingen, dvs. knappen vår. Vi oppgir også at denne parameteren kan være av typen "Hvilken som helst."

Når brukeren trykker på knappen, påkaller appen vår alarmController (_ sender :) -metoden.

Sjekk tilkoblingen

Etter å ha opprettet vår "alertController" -metode, kan vi sjekke at den er riktig koblet til knappen:

I Navigeringsområdet velger du "Main.storyboard" -filen.
I Xcodes menylinje velger du "Vis> Verktøy> Vis tilkoblingsinspektør." Tilkoblingsinspektøren skal nå åpne langs høyre side av Xcode-arbeidsområdet.
I Editor-området velger du knappen.

Tilkoblingsinspektøren skal nå vise noe informasjon om denne knappen, inkludert en "Sendte hendelser" -del, som inneholder en liste over tilgjengelige hendelser og den tilsvarende metoden som vil bli kalt når hver hendelse oppstår.

Vi kan se at hendelsen “Touch Up Inside” er koblet til vår “alertController” -metode, så vi vet at hver gang brukeren samhandler med denne knappen, vil “alertController” -metoden bli kalt.

Imidlertid er det et problem: vi har faktisk ikke definert hva som skal skje når “alertController” -metoden blir kalt!

Oppretter en varselsdialog

I iOS kan du opprette et varsel ved å bruke UIAlertController, som omtrent tilsvarer Android's AlertDialog.

Åpne filen ViewController.swift, og legg til følgende:

klasse ViewController: UIViewController {@IBAction func showAlert (_ avsender: Hvilket som helst) {let alertController = UIAlertController (tittel: "Tittel",: "Hallo, verden!", foretrukketStyle: .alert) alertController.addAction (UIAlertAction (tittel: "Avbryt) ", style: .default)) self.present (alertController, animert: true, completation: nil)}

La oss se nærmere på hva som skjer her:

1. erklære en konstant

I Swift erklærer du konstanter med "la" nøkkelordet, så vi starter med å erklære en konstant kalt alertController:

la alarmController

2. Angi innholdet

Vi kan nå definere varselens tittel og:

la alertController = UIAlertController (tittel: "Tittel",: "Hallo, verden!")

3. Angi stilen

Siden dette er et varsel, bruker jeg "Alert" -stilen:

la alertController = UIAlertController (tittel: "Tittel",: "Hallo, verden!", foretrukketStyle: .alert)

4. Legg til en handling

Deretter legger vi til en handlingsknapp ved hjelp av metoden addAction ():

alertController.addAction (UIAlertAction (tittel: "Cancel", stil: .default))

5. Vis varselet

Når vi har konfigurert UIAlertController-objektet, er vi klare til å vise det til brukeren. I det følgende utdraget ber vi ViewController om å presentere alertController-objektet med en animasjon:

self.present (alertController, animert: true, completation: nil)}

Tester den ferdige iOS-appen din

Nå er det på tide å prøve prosjektet vårt:

Velg "Kjør" -knappen på Xcodes verktøylinje.
Når applikasjonen din vises i iOS-simulatoren, gi knappen en klikk - varselet ditt skal nå vises på skjermen!

Innpakking

I denne opplæringen fikk vi litt praktisk erfaring med å utvikle for iOS. Vi opprettet en enkel applikasjon, bestående av en knapp og et varsel, mens vi ble kjent med Xcode IDE og Swift-programmeringsspråket.

Har du noen planer om å begynne å utvikle apper for iPhone og iPad? Eller foretrekker du plattformsutviklingsverktøy som Flutter? Gi oss beskjed i kommentarene nedenfor!