Lær det grunnleggende om Swift på mindre enn ti minutter

Swift er et relativt nytt programmeringsspråk designet av Apple Inc som opprinnelig ble gjort tilgjengelig for Apple-utviklere i 2014.

Det var først og fremst ment som en erstatning for det aldrende Objective-C-språket som var grunnlaget for OS X og iOS-programvareutvikling på den tiden. Det ble gjort åpen kildekode i desember 2015.

Selv om det fortsatt hovedsakelig brukes av utviklere som er målrettet mot Apple macOS og iOS-plattformer, støttes Swift også fullt ut på Linux, og det er også uoffisielle porter under utvikling for Windows.

I motsetning til mange objektorienterte språk, som er basert på eldre prosessuelle språk - for eksempel er C ++ og Objective-C basert på C - Swift ble designet fra grunnen av som et nytt, moderne, objektorientert språk som gjør programmering raskere og enklere, og hjelper utviklere å produsere ekspressiv kode som er mindre utsatt for feil enn mange språk.

Selv om det ikke var basert på et eldre språk, ble Swift, med ordene til sjefarkitekten Chris Lattner, " inspirert av å tegne ideer fra Ruby, Python, C #, CLU og altfor mange andre til å liste opp ".

I dette raske kollisjonskurset vil vi dekke det grunnleggende ved å bruke Swift-programmeringsspråket. Du lærer:

  • Grunnleggende Swift-syntaks
  • Rask programstruktur
  • Variabler og konstanter
  • Skriv inn slutning
  • Variable og konstante navngivningskonvensjoner
  • Utskrift og strenginterpolasjon

La oss komme i gang!

Dette krasjkurset er tilpasset Next Techs fullstendige begynnelseskurs, som inkluderer et sandkassemiljø i nettleseren med Swift forhåndsinstallert. Det har også mange aktiviteter du kan fullføre. Du kan sjekke det gratis her!

Rask syntaks

I denne første delen ser vi på den grunnleggende språksyntaksen for Swift.

Som mange moderne programmeringsspråk, trekker Swift sin mest grunnleggende syntaks fra programmeringsspråket C. Hvis du har tidligere programmeringserfaring på andre C-inspirerte språk, vil mange aspekter av Swift virke kjent, for eksempel:

  • Programmene består av uttalelser, utført sekvensielt.
  • Mer enn ett utsagn er tillatt per redigeringslinje når det skilles med semikolon ( ;).
  • Arbeidsenheter i Swift blir modulert ved hjelp av funksjoner og organisert i typer.
  • Funksjoner godtar en eller flere parametere og returnerer verdier.
  • Enkeltkommentarer og flerlinjekommentarer følger samme syntaks som i C ++ og Java.
  • Swift datatypenavn og bruk ligner på Java, C # og C ++.
  • Swift har konseptet med navngitte variabler, som er foranderlige, og navngitte konstanter, som er uforanderlige.
  • Swift har både struktur- og klassesemantikk, det samme gjør C ++ og C #.

Imidlertid har Swift noen forbedringer og forskjeller fra C-inspirerte språk som du kanskje må bli vant til, for eksempel:

  • Semikolon er ikke nødvendig på slutten av utsagnene - bortsett fra når de brukes til å skille flere utsagn skrevet på samme linje i en kildefil.
  • Swift har ingen main()metode for å fungere som programmets utgangspunkt når operativsystemet laster applikasjonen. Swift-programmer begynner på den første linjen med kode i programmets kildefil - slik det er i de fleste tolket språk.
  • Funksjoner i Swift plasserer funksjonstypen tilbake på høyre side av funksjonserklæringen, i stedet for til venstre.
  • Syntaks for erklæring om funksjonsparameter er inspirert av Objective-C, som er ganske annerledes og ofte til å begynne med forvirrende for Java, C # og C ++ utviklere.
  • Forskjellen mellom en struct og en klasse i Swift er lik den vi har i C # (verditype versus referansetype), men ikke den samme som i C ++ (begge er de samme, bortsett fra at struct-medlemmer er offentlige som standard).

Rask programstruktur - Hello, World!

For å illustrere den grunnleggende strukturen til et Swift-program, la oss lage et enkelt Swift-program for å vise strengen Hello, World.til konsollen:

[Out:]Hello, World
Hvis du bruker Next Techs sandkasse, kan du følge med kodebitene i dette kollisjonskurset ved å bare skrive inn redigereren. Ellers kan du følge med din egen IDE - bare sørg for at Swift er installert!

Gratulerer! I to kodelinjer har du nettopp skrevet ditt første fullt funksjonelle Swift-program.

La oss nå gå videre til å lære om og bruke Swift-språket - og bryte ned hver del av Hello Worldprogrammet ditt!

Raske variabler

Nesten alle programmeringsspråk inkluderer muligheten for programmerere til å lagre verdier i minnet ved hjelp av et tilknyttet navn valgt av programmereren. Variabler gjør det mulig for programmer å operere på dataverdier som endres under løpet av programmet.

En Swift-variabelerklæring bruker følgende grunnleggende 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!