Lær det grundlæggende i Swift på mindre end ti minutter

Swift er et relativt nyt programmeringssprog designet af Apple Inc, der oprindeligt blev gjort tilgængeligt for Apple-udviklere i 2014.

Det var primært beregnet som erstatning for det aldrende Objective-C-sprog, der var grundlaget for OS X og iOS-softwareudvikling på det tidspunkt. Det blev gjort open source i december 2015.

Mens det fortsat primært bruges af udviklere, der er målrettet mod Apple macOS og iOS-platforme, understøttes Swift også fuldt ud på Linux, og der er også uofficielle porte under udvikling for Windows.

I modsætning til mange objektorienterede sprog, der er baseret på ældre processprog - for eksempel er C ++ og Objective-C baseret på C - Swift blev designet fra bunden som et nyt, moderne, objektorienteret sprog, der gør programmering hurtigere og lettere og hjælper udviklere med at producere ekspressiv kode, der er mindre tilbøjelig til fejl end mange sprog.

Selvom det ikke var baseret på et ældre sprog, blev Swift med ordene fra sin chefarkitekt Chris Lattner inspireret af at tegne ideer fra Ruby, Python, C #, CLU og alt for mange andre til at nævne .

I dette hurtige nedbrudskurs vil vi dække det grundlæggende ved at bruge Swift-programmeringssproget. Du lærer:

  • Grundlæggende Swift-syntaks
  • Hurtig programstruktur
  • Variabler og konstanter
  • Skriv slutning
  • Variable og konstante navngivningskonventioner
  • Udskrivning og strenginterpolation

Lad os komme igang!

Dette crashkursus er tilpasset Next Tech's fulde Beginning Swift-kursus, som inkluderer et sandbox-miljø i browseren med forudinstalleret Swift. Det har også adskillige aktiviteter, du kan gennemføre. Du kan tjekke det gratis her!

Hurtig syntaks

I dette første afsnit ser vi på den grundlæggende sprogsyntaks for Swift.

Som mange moderne programmeringssprog trækker Swift sin mest basale syntaks fra programmeringssprog C.Hvis du har tidligere programmeringserfaring på andre C-inspirerede sprog, vil mange aspekter af Swift virke velkendte, for eksempel:

  • Programmer består af udsagn, udført sekventielt.
  • Mere end en sætning er tilladt pr. Editorlinje, når den adskilles af et semikolon ( ;).
  • Arbejdsenheder i Swift moduleres ved hjælp af funktioner og organiseres i typer.
  • Funktioner accepterer en eller flere parametre og returnerer værdier.
  • Enkelte og multiline kommentarer følger den samme syntaks som i C ++ og Java.
  • Hurtige datatypenavne og -brug svarer til Java, C # og C ++.
  • Swift har begrebet navngivne variabler, som er mutable, og navngivne konstanter, som er uforanderlige.
  • Swift har både struktur- og klassesemantik, ligesom C ++ og C # har det.

Imidlertid har Swift nogle forbedringer og forskelle fra C-inspirerede sprog, som du måske bliver vant til, såsom:

  • Semikoloner kræves ikke i slutningen af ​​udsagn - undtagen når de bruges til at adskille flere udsagn skrevet på den samme linje i en kildefil.
  • Swift har ingen main()metode til at fungere som programmets startpunkt, når operativsystemet indlæser applikationen. Swift-programmer begynder ved den første linje med kode i programmets kildefil - som det er tilfældet i de fleste fortolkede sprog.
  • Funktioner i Swift placerer funktionsreturtypen i højre side af funktionserklæringen i stedet for til venstre.
  • Syntaks for erklæring om funktionsparameter er inspireret af Objective-C, som er ret anderledes og ofte i første omgang forvirrende for Java-, C #- og C ++ -udviklere.
  • Forskellen mellem en struktur og en klasse i Swift svarer til, hvad vi har i C # (værditype versus referencetype), men ikke den samme som i C ++ (begge er de samme, bortset fra at struct-medlemmer er offentlige som standard).

Hurtig programstruktur - Hello, World!

For at illustrere den grundlæggende struktur i et Swift-program, lad os oprette et simpelt Swift-program til at vise strengen Hello, World.til konsollen:

[Out:]Hello, World
Hvis du bruger Next Techs sandkasse, kan du følge med kodebitene i dette crashkurs ved blot at skrive editoren. Ellers kan du følge med din egen IDE - bare sørg for, at Swift er installeret!

Tillykke! I to linier kode har du lige skrevet dit første fuldt funktionelle Swift-program.

Lad os nu gå videre til at lære om og bruge Swift-sproget - og nedbryde hver del af dit Hello Worldprogram!

Hurtige variabler

Næsten alle programmeringssprog inkluderer programmørernes mulighed for at gemme værdier i hukommelsen ved hjælp af et tilknyttet navn valgt af programmøren. Variabler tillader programmer at fungere på dataværdier, der ændres under programkørslen.

En Swift-variabelerklæring bruger følgende grundlæggende syntaks:

var : t; =

Given this syntax, a legal declaration for a variable called pi would be:

This declaration means: “create a variable named pi , which stores a Doubledata type, and assign it an initial value of 3.14159”.

Swift Constants

You may want to store a named value in your program that will not change during the life of the program. How can we ensure that, once defined, this named value can never be accidentally changed by our code? By declaring a constant!

In our earlier Hello, World program, we declared message using let instead of var — therefore, message is a constant.

Since message was declared as a constant, if we added the following line of code to the end of our program, we would receive a compile-time error, since changing a let constant is illegal:

[Out:]error: cannot assign to value: ‘message’ is a ‘let’ constant

Generally, any time you create a named value that will never be changed during the run of your program, you should use the let keyword to create a constant. The Swift compiler enforces this recommendation by creating a compile-time warning whenever a var is created that is not subsequently changed.

Other than the restriction on mutating the value of a constant once declared, Swift variables and constants are used in virtually identical ways.

Type Inference

In our Hello World example, we created the constant message without specifying its data type. We took advantage of a Swift compiler feature called type inference.

When you assign the value of a variable or constant as you create it, the Swift compiler will analyze the right-hand side of the assignment, infer the data type, and assign that data type to the variable or constant you’re creating. For example, in the following declaration, the compiler will create the variable name as a String data type:

As a type-safe language, once a data type is inferred by the compiler, it remains fixed for the life of the variable or constant. Attempting to assign a non-string value to the name variable declared above would result in a compile-time error:

[Out:]error: “cannot assign value of type ‘Double’ to type ‘String’

While Swift is a type-safe language, where variable types are explicit and do not change, it is possible to create Swift code that behaves like a dynamic type language using the Swift Any data type. For example, the following code is legal in Swift:

While this is legal, it’s not a good Swift programming practice. The Any type is mainly provided to allow bridging between Objective-C and Swift code. To keep your code as safe and error-free as possible, you should use explicit types wherever possible.

Variable Naming Conventions

Swift variables and constants have the same naming rules as most C-inspired programming languages:

  • Must not start with a digit
  • After the first character, digits are allowed
  • Can begin with and include an underscore character
  • Symbol names are case sensitive
  • Reserved language keywords may be used as variable names if enclosed in backticks. For example:

When creating variable and constant names in Swift, the generally accepted naming convention is to use a camelCase naming convention, beginning with a lowercase letter. Following generally accepted naming conventions makes code easier for others to read and understand.

For example, the following would be a conventional variable declaration:

However, the following would not be conventional, and would be considered incorrect by many other Swift developers:

Unlike many other programming languages, Swift is not restricted to the Western alphabet for its variable name characters. You may use any Unicode character as part of your variable declarations. The following variable declarations are legal in Swift:

Note that just because you can use any Unicode character within a variable name, and can use reserved words as variables when enclosed in backticks, it doesn’t mean you should. Always consider other developers who may need to read and maintain your code in the future. The priority for variable names is that they should make code easier to read, understand, and maintain.

Printing and String Interpolation

In Swift, you can print a variable or a constant to your console using the print() function. Let’s create a variable and a constant and print them out.

Execute this snippet in your Code Editor to create a constant named name, and a variable named address:

[Out:]John Does lives at 201 Main Street

Both name and address store string text. By wrapping the variable or constant name in a pair of parentheses, prefixed by a backslash (\), we are able to print their stored values in a print statement — this is called string interpolation.

I hope you enjoyed this quick crash course on the basics of Swift! We learned about basic syntax and program structure, how to declare and use Swift variables and constants, type inference, printing, and string interpolation.

If you are interested in learning more about Swift, we have a full Beginning Swift course at Next Tech that you can start for free! In this course we cover:

  • Other basic programming concepts such as: optionals, tuples, enums, conditionals and loops, methods, structs, and classes.
  • Creating scripts and command line applications in Swift
  • Using Swift outside of iOS and macOS development lifecycles

Happy learning!