Swift Academy · Lektion

Argumentetiketter och parameternamn

Förstå externa och interna parameternamn samt hur Swifts anropssyntax liknar engelska.

Lektion 1 av 412 steg

Argumentetiketter och parameternamn är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 4 lektioner.

Välkommen

Swift-funktioner har två namn för varje parameter: en *extern* argumentetikett som används vid anropet och ett *internt* parameternamn som används i funktionskroppen.

Externa och interna namn

```swift func greet(person name: String) { print("Hello, \(name)!") } greet(person: "Alice") // call site uses 'person' // body uses 'name' ``` Den externa etiketten gör anropet mer lättläst.

Utelämna den externa etiketten med `_`

Använd `_` för att undertrycka argumentetiketten: ```swift func square(_ n: Int) -> Int { n * n } print(square(5)) // 25 — no label needed ``` Vanligt i matematik- och hjälpfunktioner där etiketten skulle bli överflödig.

Etiketter som följer engelskan

Väl valda etiketter gör att anrop läses som meningar: ```swift func move(from source: String, to destination: String) {} move(from: "Home", to: "Work") ``` Detta är en central princip i Swift för API-design.

Samma externa och interna namn

När bara ett namn anges fungerar det som båda: ```swift func add(a: Int, b: Int) -> Int { a + b } add(a: 3, b: 4) // label == parameter name ``` En vanlig stil för enkla funktioner.

Flera parametrar

```swift func divide(_ numerator: Double, by denominator: Double) -> Double { numerator / denominator } let result = divide(10.0, by: 2.0) // 5.0 ``` Den första parametern saknar ofta etikett; följande parametrar har beskrivande etiketter.

Parameteretiketter i API:er

Apples egna API:er visar detta mönster: ```swift array.insert(42, at: 0) string.replacingOccurrences(of: "a", with: "b") URLSession.shared.dataTask(with: request) ``` Läs varje anrop högt – det ska låta naturligt.

Överlagring med olika etiketter

Funktioner med samma namn men olika etiketter är separata: ```swift func load(url: String) {} func load(file: String) {} load(url: "https://example.com") load(file: "/tmp/data.json") ``` Etiketter skiljer överlagringar åt utan att basnamnet ändras.

Kapslade funktionsanrop och etiketter

Etiketter gäller även i kapslade anrop: ```swift func stringify(_ n: Int) -> String { "\(n)" } func print(line value: String) { print(value) } print(line: stringify(42)) // "42" ```

Bästa praxis

Riktlinjer: • Utelämna den första etiketten när funktionsnamnet antyder den: `makeURL(string:)` → `makeURL("…")` • Använd grammatiska prepositioner som externa etiketter: `at`, `with`, `from`, `to` • Undvik etiketter som upprepar typinformation: `func add(intValue v: Int)` är överflödig

Snabbtest

Vilken symbol undertrycker den externa argumentetiketten vid anropet?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Viktiga punkter: • `func f(external internal: Type)` — två namn, det externa används vid anropet • `_` undertrycker den externa etiketten • Väl valda etiketter gör att anrop läses som engelska meningar • Samma etikett och namn används när bara ett namn anges Nästa: standardvärden och variadiska parametrar.

Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 122
Lektioner: 409

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Argumentetiketter och parameternamn” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Argumentetiketter och parameternamn”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Argumentetiketter och parameternamn”?

Förstå externa och interna parameternamn samt hur Swifts anropssyntax liknar engelska. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Argumentetiketter och parameternamn”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Swift Academy