Swift Academy · Lektion

Argumentbezeichnungen und Parameternamen

Verstehen Sie externe und interne Parameternamen und wie Swifts Aufrufsyntax wie Englisch liest.

Lektion 1 von 412 Schritte

Argumentbezeichnungen und Parameternamen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Swift-Funktionen haben für jeden Parameter zwei Namen: eine *externe* Argumentbezeichnung, die am Aufrufort verwendet wird, und einen *internen* Parameternamen, der im Funktionskörper verwendet wird.

Externe und interne Namen

```swift func greet(person name: String) { print("Hello, \(name)!") } greet(person: "Alice") // call site uses 'person' // body uses 'name' ``` Die externe Bezeichnung verbessert die Lesbarkeit am Aufrufort.

Externe Bezeichnung mit _ weglassen

Verwenden Sie `_`, um die Argumentbezeichnung zu unterdrücken: ```swift func square(_ n: Int) -> Int { n * n } print(square(5)) // 25 — no label needed ``` Das ist bei mathematischen Funktionen und Hilfsfunktionen üblich, wenn die Bezeichnung redundant wäre.

Bezeichnung an englische Formulierungen anpassen

Gut gewählte Bezeichnungen sorgen dafür, dass Aufrufe wie Sätze lesbar sind: ```swift func move(from source: String, to destination: String) {} move(from: "Home", to: "Work") ``` Dies ist ein grundlegendes Prinzip des Swift-API-Designs.

Gleicher externer und interner Name

Wenn nur ein Name angegeben wird, dient er als beides: ```swift func add(a: Int, b: Int) -> Int { a + b } add(a: 3, b: 4) // label == parameter name ``` Das ist ein üblicher Stil für einfache Funktionen.

Mehrere Parameter

```swift func divide(_ numerator: Double, by denominator: Double) -> Double { numerator / denominator } let result = divide(10.0, by: 2.0) // 5.0 ``` Der erste Parameter hat häufig keine Bezeichnung, während nachfolgende Parameter beschreibende Bezeichnungen erhalten.

Parameterbezeichnungen in APIs

Die APIs von Apple veranschaulichen dieses Muster: ```swift array.insert(42, at: 0) string.replacingOccurrences(of: "a", with: "b") URLSession.shared.dataTask(with: request) ``` Lesen Sie jeden Aufruf laut vor – er sollte natürlich klingen.

Überladen mit unterschiedlichen Bezeichnungen

Funktionen mit demselben Namen, aber unterschiedlichen Bezeichnungen sind eigenständige Funktionen: ```swift func load(url: String) {} func load(file: String) {} load(url: "https://example.com") load(file: "/tmp/data.json") ``` Bezeichnungen unterscheiden Überladungen, ohne den Basisnamen zu verändern.

Verschachtelte Funktionsaufrufe und Bezeichnungen

Bezeichnungen gelten auch bei Verschachtelungen: ```swift func stringify(_ n: Int) -> String { "\(n)" } func print(line value: String) { print(value) } print(line: stringify(42)) // "42" ```

Bewährte Vorgehensweisen

Richtlinien: • Lassen Sie die erste Bezeichnung weg, wenn der Funktionsname ihre Bedeutung bereits enthält: `makeURL(string:)` → `makeURL("…")` • Verwenden Sie grammatikalische Präpositionen als externe Bezeichnungen: `at`, `with`, `from`, `to` • Vermeiden Sie Bezeichnungen, die die Typinformation wiederholen: `func add(intValue v: Int)` ist redundant

Schnelltest

Welches Symbol unterdrückt die externe Argumentbezeichnung am Aufrufort?

Beantworte es in der interaktiven Lektion

Zusammenfassung

Die wichtigsten Punkte: • `func f(external internal: Type)` – zwei Namen, der externe am Aufrufort • `_` unterdrückt die externe Bezeichnung • Gut gewählte Bezeichnungen lassen Aufrufe wie englische Sätze lesen • Wenn nur ein Name angegeben wird, sind Bezeichnung und Name identisch Als Nächstes: Standard- und variadische Parameter.

Kostenlos starten

Lerne Swift mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 122
Lektionen: 409

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Argumentbezeichnungen und Parameternamen“ kostenlos?

Ja — der vollständige Text von „Argumentbezeichnungen und Parameternamen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Argumentbezeichnungen und Parameternamen“?

Verstehen Sie externe und interne Parameternamen und wie Swifts Aufrufsyntax wie Englisch liest. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Swift Academy zu starten?

Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Argumentbezeichnungen und Parameternamen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?

Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Argumentbezeichnungen und Parameternamen
Standard- und variadische Parameter
In-Out-Parameter und mehrere Rückgabewerte
Funktionen als erstklassige Werte

← Zurück zu Swift Academy