Föreläsning i det stora köket

Jag märkte att människorna runt omkring mig då och då kastade blickar på mig. Jag tror att det beror på att de vet att jag är en tidsresenär. Det ger mig också känslan av att jag inte är härifrån, att jag är annorlunda. Och ibland är det svårt att vara annorlunda. Men det är inte mycket jag kan göra åt det, så jag kan bara göra mitt bästa.

När uppgiften för morgonsessionen var avklarad och vi hade ätit lunch satte vi oss till rätta för den andra delen av Ritchies lektion om nya typer. "Vi tar det lugnt i eftermiddag", sa Ritchie, "och lär er bara om en typ till idag."

Char-typen

Han fortsatte, "Namnet på denna typ är char. Den representerar ett enskilt tecken: en bokstav, en siffra eller något annat symbol som du kan tänka dig. För att representera ett char-värde i C# måste du omge det med enkla citattecken: ' s '. Här är ett exempel på hur man skapar en char-variabel." Ritchie återvände till whiteboarden.

char someLetter = 'a';
char someSymbol = '?';
char anotherOne = '+';

"Du kan läsa in en char från konsolen med hjälp av metoden char.Parse(...), på samma sätt som du gjorde med double och int":

string input = Console.ReadLine();
char inputSymbol = char.Parse(input);

"För att skriva ut en char-variabel till konsolen kan du använda metoden Console.WriteLine(...), på samma sätt som med de andra typerna vi känner till. Till exempel":

char someChar = 'h';
Console.WriteLine(someChar); // Outputs: h
Console.WriteLine('h'); // Outputs: h
Console.WriteLine('#'); // Outputs: #

"Ritchie", ropade någon, "är inte en char bara en del av en string?"

"Tja..." började han, "man kan säga att en char kan vara en del av en string. Som du vet består strängar av tecken. I C# kan du få en char genom att begära data från en plats i strängen. Betrakta en sträng: "Resistance". Du kan få ut det första tecknet 'R' ur strängen genom att lägga till [0] i slutet av strängen, så här: "Resistance"[0]. Du kan få ut det andra tecknet ur strängen genom att lägga till [1] i slutet av strängen: "Resistance"[1]. Du kan se ett mönster här - slutligen kan du få det n:te tecknet i strängen genom att lägga till [n-1] i slutet av strängen: "Resistance"[n-1]. Så här":

char firstCharacter = "Resistance"[0];
char secondCharacter = "Resistance"[1];
char thirdCharacter = "Resistance"[2];
char oneBeforeLastCharacter = "Resistance"[8];

Console.WriteLine(firstCharacter);          // Outputs: R
Console.WriteLine(secondCharacter);         // Outputs: e
Console.WriteLine(thirdCharacter);          // Outputs: s
Console.WriteLine(oneBeforeLastCharacter);  // Outputs: c

"Detta öppnar upp unika möjligheter. Du kan använda en int-variabel som ett index i hakparenteserna [] tillsammans med strängvariabeln också."

string resistance = "Resistance";
char firstCharacter = resistance[0];
char oneBeforeLastCharacter = resistance[8];

Console.WriteLine(firstCharacter);          // Outputs: R
Console.WriteLine(oneBeforeLastCharacter);  // Outputs: c
Console.WriteLine(resistance[8]);           // Outputs: c
Console.WriteLine(resistance[3]);           // Outputs: i

int index = 3;
Console.WriteLine(resistance[index]);       // Outputs: i

"Du kan även utföra andra funktioner på en char, som att kontrollera om det är en stor bokstav, en liten bokstav, en siffra, osv. Här är en fullständig lista över char-funktioner. Här är de mest använda":

1. char.IsDigit(someChar) - kontrollerar om someChar är en decimal siffra. Returnerar ett bool-värde.
2. char.IsLetter(someChar) - kontrollerar om someChar är en bokstav. Returnerar ett bool-värde.
3. char.IsLower(someChar) - kontrollerar om someChar är en gemener (liten bokstav). Returnerar ett bool-värde.
4. char.IsUpper(someChar) - kontrollerar om someChar är en versal (stor bokstav). Returnerar ett bool-värde.

char someChar = 'A';
if (char.IsDigit(someChar))
{
    Console.WriteLine($"{someChar} is a digit");
}
else
{
    Console.WriteLine($"{someChar} is NOT a digit");
}

if (char.IsLetter(someChar))
{
    if (char.IsUpper(someChar))
    {
        Console.WriteLine($"{someChar} is an uppercase letter");
    }
    else
    {
        Console.WriteLine($"{someChar} is a lowercase case letter");
    }
}
else
{
    Console.WriteLine($"{someChar} is NOT a letter");
}

// Outputs:
// A is NOT a digit
// A is an uppercase letter

Ritchie lade ifrån sig pennan och suddade ut det han skrivit på whiteboarden. "Nu, håll i er inför nästa påstående." fortsatte han och talade långsamt och målmedvetet, "En char representeras som ett nummer i datorminnet."

Det var knäpptyst när vi försökte förstå detta. Någon längst bak ställde frågan som vi alla tänkte på: "Du sa precis att en char är en bokstav. Hur kan den vara ett nummer?"

"Det låter inte så enkelt", jag vet. "Men en char representeras faktiskt av ett nummer. Strängvariabler representeras också av nummer. Ni måste komma ihåg att en datorprocessor bara kan tolka nummer. Den förstår inte tecken och strängar. De skapades för att göra våra liv enklare. När du skriver följande,

char someChar = 'a';

är detta vad som händer i minnet":

"Behöver vi veta hur char är lagrat, Ritchie?" frågade någon.

"Ja, åtminstone för att kunna använda Console.Read()."

"Menar du Console.ReadLine()?"

"Nej, jag menar Console.Read(). Även om de är liknande, läser den här metoden bara in en char från konsolen och returnerar den till dig, istället för en sträng som Console.ReadLine() gör. Här är ett exempel":

int charCode = Console.Read();

"Du har kanske lagt märke till att i koden ovan returnerar Console.Read() en int, inte en char. Denna int representerar det nummer som faktiskt lagras i minnet för den char. Till exempel lagras 'a' som 97; 'A' som 65; och 'μ' som 181. I C# görs korrespondensen mellan det verkliga tecknet och dess numeriska representation genom Unicode-branschstandarden. I princip binder den tecken till nummer. Du kan enkelt hitta en lista över Unicode-tecken på nätet.

För att konvertera en numerisk char-representation, säg 97, till ett verkligt tecken som 'a', kan du använda metoden Convert.ToChar(charCode)."

int charCode = Console.Read(); // Reads Unicode representation of the char
char theRealChar = Convert.ToChar(charCode); // Converts Unicode code of the
                                             // char to a char type

"Koden ovan väntar på att användaren ska ange ett tecken (det kan även vara flera tecken) och trycka på Enter. Programmet läser sedan tecknets Unicode-kod och konverterar den till en char-typ. Prova själv!"

"Det finns också metoden Console.Write(...). Den skriver ut vad du ger den på skärmen, men byter inte rad efter varje utskrift som Console.WriteLine(...) gör. Du kan använda Console.Write(...) med strängar, ints, chars, osv. på samma sätt som du gjorde med Console.WriteLine(...). Här är några exempel":

char two = '2';
char a = 'a';
char b = 'b';
Console.Write(two);
Console.Write(a);
Console.Write(b);

// Outputs: 2ab

int two = 2;
int ten = 10;
int five = 5;
Console.Write(two);
Console.Write(ten);
Console.Write(five);

// Outputs: 2105

char two = '2';
int ten = 10;
int five = 5;
Console.Write(two);
Console.Write(ten);
Console.WriteLine(five);

// Outputs: 2105

char two = '2';
int ten = 10;
int five = 5;
Console.Write(two);
Console.Write(ten);
Console.WriteLine(five);
Console.Write(five);

// Outputs: 2105
// 5

Console.Write("Hello, ");
Console.Write("Teo!");

// Outputs: Hello, Teo!

Efter att ha arbetat oss igenom alla dessa exempel började en del packa ihop för att lämna köket. En hel dag av inlärning hade gått, och vi hade en helt ny uppsättning typer att använda i vår kod! Innan någon hade nått dörrarna ropade Ritchie över sorlet att en sista lektion skulle klaras av.

"Innan ni går vill jag tillägga att ni kan jämföra chars med ' > ' och ' < '. Jämförelsen görs i alfabetisk ordning: 'a' är mindre än 'b'; och dessa jämförelser är skiftlägeskänsliga, vilket betyder att du bara ska jämföra versaler med versaler och gemener med gemener. Här är några exempel.":

if ('a' < 'b')
{
    Console.WriteLine("True!");
}

if ('M' > 'Z')
{
    Console.WriteLine("False!");
}

// Outputs: True!