Övning – Skriva ut literalvärden

10 minuter

I den här övningen skriver du ut meddelanden som innehåller andra typer av data och lär dig varför datatyper är så viktiga i C#.

Vad är ett literalvärde?

Ett literalvärde är ett konstant värde som aldrig ändras. Tidigare visade du en literalsträng i utdatakonsolen. Med andra ord ville du bokstavligen att strängen med alfanumeriska tecken H, , e, ll, och oså vidare skulle visas i utdatakonsolen.

Använd strängdatatypen när du har alfanumeriska ord, fraser eller data för presentation, inte beräkning. Vilka andra typer av literaldata kan du skriva ut till utdata?

Övning – Skriva ut olika typer av literaldata

Det finns många datatyper i C#. Men när du kommer igång behöver du bara veta om fem eller sex datatyper eftersom de täcker de flesta scenarier. Nu ska vi visa en literal instans av datatypen för utdata.

Kommentar

När du börjar skriva i kodfönstret kanske du lägger märke till att syntaxen får olika färger som indikerar element som nyckelord, operatorer och datatyper. Börja lägga märke till de här färgerna. Det kan hjälpa dig att upptäcka syntaxfel när du anger tecken och kan hjälpa dig att förstå koden mer effektivt.

Använda teckenliteraler

Om du bara vill att ett enda alfanumeriskt tecken ska skrivas ut på skärmen kan du skapa en teckenliteral genom att omge ett alfanumeriskt tecken inom enkla citattecken. Termen char är kort för tecken. I C# heter den här datatypen officiellt "char", men kallas ofta för ett "tecken".

Lägg till följande kodrad i kodredigeraren:
```
Console.WriteLine('b');
```
Observera den kod som du angav.

Observera att bokstaven b är omgiven av enkla citattecken 'b'. Enkla citattecken skapar en teckenliteral. Kom ihåg att om du använder dubbla citattecken skapas en string datatyp.
Tryck på den gröna knappen Kör för att köra koden. Du bör se följande resultat i utdatafönstret:
```
b
```

Om du anger följande kod:

Console.WriteLine('Hello World!');

Bör du se följande fel:

(1,19): error CS1012: Too many characters in character literal

Observera de enkla citattecken som omger Hello World!. När du använder enkla citattecken förväntar sig C#-kompilatorn ett enda tecken. I det här fallet användes dock teckenliteralsyntaxen, men 12 tecken angavs i stället!

Precis som string datatypen använder char du när du har ett enda alfanumeriskt tecken för presentation (inte beräkning).

Använda heltalsliteraler

Om du vill visa ett numeriskt heltalsvärde (inga bråktal) i utdatakonsolen kan du använda en int-literal. Termen int är kort för heltal, som du kanske känner igen från att studera matematik. I C# heter den här datatypen officiellt "int", men kallas ofta för "heltal". En int literal kräver inga andra operatorer som string eller char.

Lägg till följande kodrad i kodredigeraren:
```
Console.WriteLine(123);
```
Tryck på den gröna knappen Kör för att köra koden. Du bör se följande resultat i utdatakonsolen:
```
123
```

Använda flyttalsliteraler

Ett flyttalsnummer är ett tal som innehåller ett decimaltal, till exempel 3,14159. C# stöder tre datatyper för att representera decimaltal: float, doubleoch decimal. Varje typ har stöd för varierande precisionsgrader.

Float Type    Precision
----------------------------
float         ~6-9 digits
double        ~15-17 digits
decimal        28-29 digits

Här återspeglar precision antalet siffror som passerat decimaltecknet som är korrekta.

Lägg till följande kodrad i kodredigeraren:
```
Console.WriteLine(0.25F);
```
Om du vill skapa en float literal lägger du till bokstaven F efter talet. I det här sammanhanget kallas F för ett literalsuffix. Suffixet literal anger för kompilatorn att du vill arbeta med ett värde av float typen. Du kan använda antingen gemener f eller versaler F som literalsuffix för en float.
Tryck på den gröna knappen Kör för att köra koden. Du bör se följande resultat i utdatakonsolen:
```
0.25
```
Observera att float datatypen är minst exakt, så det är bäst att använda den här datatypen för fasta bråkvärden för att undvika oväntade beräkningsfel.
Lägg till följande kodrad i kodredigeraren:
```
Console.WriteLine(2.625);
```
Om du vill skapa en double literal anger du bara ett decimaltal. Kompilatorn använder som standard en double literal när ett decimaltal anges utan ett literalsuffix.
Tryck på den gröna knappen Kör för att köra koden. Du bör se följande resultat i utdatafönstret:
```
2.625
```
Lägg till följande kodrad i kodredigeraren:
```
Console.WriteLine(12.39816m);
```
Du kan skapa en decimal-literal genom att lägga till bokstaven m efter talet. I det här sammanhanget kallas m för ett literalsuffix. Suffixet literal anger för kompilatorn att du vill arbeta med ett värde av decimal typen. Du kan använda antingen gemener m eller versaler M som literalsuffix för en decimal.
Tryck på den gröna knappen Kör för att köra koden. Du bör se följande resultat i utdatakonsolen:
```
12.39816
```

Använda booleska literaler

Om du vill skriva ut ett värde som representerar antingen true eller falsekan du använda en boolliteral.

Termen bool är kort för boolesk. I C# kallas de officiellt "bool", men ofta använder utvecklare termen "boolesk".

Lägg till följande kodrader i kodredigeraren:

Console.WriteLine(true);
Console.WriteLine(false);

Tryck på den gröna knappen Kör för att köra koden. Du bör se följande resultat i utdatakonsolen:
```
True
False
```

Literalerna bool representerar idén om sanning och lögn. Du använder bool värden i stor utsträckning när du börjar lägga till beslutslogik i dina program. Du utvärderar uttryck för att se om uttrycket är sant eller falskt.

Varför är det viktigt med datatyper?

Datatyper har en central betydelse i C#. I själva verket är betoningen på datatyper en av de viktigaste särskiljande funktionerna i C# jämfört med andra språk som JavaScript. De som skapade C# ville hjälpa utvecklare att undvika vanliga buggar genom att framtvinga datatyper. Du kommer lära dig mer om det här begreppet när du lär dig mer om C#.

Datatyper definierar funktioner

Tidigare såg du att strings och chars används för "presentation, inte beräkning". Om du behöver utföra en matematisk operation på numeriska värden ska du använda datatypen int eller decimal. Om du har data som används för presentation eller textmanipulering bör du använda en string datatyp eller char datatyp.

Anta att du behövde samla in data från en användare, till exempel ett telefonnummer eller postnummer. Beroende på land/region där du bor kan dessa data bestå av numeriska tecken. Men eftersom du sällan utför matematiska beräkningar på telefonnummer och postnummer är det bättre att använda datatypen string när du arbetar med dem.

Samma sak gäller för typen bool. Om du behöver arbeta med orden "true" och "false" i ditt program använder du datatypen string. Om du däremot behöver arbeta med begreppen true och false i en utvärdering ska du använda datatypen bool.

Det är viktigt att du känner till att de här värdena kan se likadana ut som motsvarande string-literaler. Du kan alltså vara lätt att tro att de här uttrycken är ekvivalenta:

Console.WriteLine("123");
Console.WriteLine(123);

Console.WriteLine("true");
Console.WriteLine(true);

Det är dock bara de utdata som visas som verkar vara liknande. I själva verket kan du göra hela andra saker med int- eller bool-värden än med motsvarande string-värden.

Sammanfattning

Det viktigaste är att det finns många datatyper, men du fokuserar bara på några få för tillfället:

string för ord, fraser eller alfanumeriska data för presentation, inte beräkning
char för ett enda alfanumeriskt tecken
int för ett heltal
decimal för ett tal med en bråkkomponent
bool för ett true/false värde

Fortsätt