Smarta blockkedjekontrakt med Solidity · Lektion

Datatyper och variabler i Solidity

Lär er om värdetyper och referenstyper samt hur variabler deklareras och initieras i Solidity.

Lektion 1 av 412 steg

Datatyper och variabler i Solidity är en gratis lektion i Smarta blockkedjekontrakt med Solidity på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Smarta blockkedjekontrakt med Solidity, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Datatyper: grunderna

Välkommen till Solidity! Precis som i alla programmeringsspråk är det grundläggande att förstå datatyper.

Datatyper talar om för Solidity vilken typ av information en variabel ska innehålla. Det hjälper Ethereum Virtual Machine (EVM) att hantera minnet effektivt och förebygga vanliga fel.

Värdetyper förklarade

Värdetyper är de enklaste datatyperna. När du tilldelar en variabel av en värdetyp eller skickar den till en funktion skapas en kopia av datan.

Tänk på det som att ge någon ett fotografi – personen får sin egen kopia, och ändringar i den kopian påverkar inte din. Värdet lagras direkt på variabelns plats.

Booleska värden och heltal

Vi börjar med vanliga värdetyper:

bool: Innehåller true eller false.
uint: Osignerade heltal (icke-negativa tal). uint256 eller helt enkelt uint är standard.
int: Signerade heltal (positiva eller negativa tal). int256 eller int är standard.

Prova att köra det här enkla kontraktet för att se dem i praktiken:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract MyNumbers {
  bool public isActive = true;
  uint public quantity = 100;
  int public temperature = -5;

  function getStatus() public view returns (bool) {
    return isActive;
  }

  function getQuantity() public view returns (uint) {
    return quantity;
  }

  function getTemperature() public view returns (int) {
    return temperature;
  }
}

Address-typen

Typen address är central i Solidity. Det är ett 20-byte-värde som representerar ett Ethereum-konto eller ett kontrakt på blockchainen.

address: Kan innehålla vilken Ethereum-adress som helst.
address payable: Kan också innehålla en Ethereum-adress, men specifikt en som kan ta emot Ether.

Så här kan du lagra adressen till kontraktets ägare:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract SimpleWallet {
  address public owner;

  constructor() {
    owner = msg.sender; // The address that deployed this contract
  }

  function getOwner() public view returns (address) {
    return owner;
  }
}

Bytearrayer med fast storlek

Solidity har även bytearrayer med fast storlek: från bytes1 till bytes32.

De är användbara för att lagra små sekvenser av råa byte med fast längd, till exempel kryptografiska hashvärden eller korta identifierare. De är effektivare än dynamiska arrayer när storleken är känd.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DataStore {
  bytes32 public documentHash;

  constructor() {
    // Example: A hash of some document content
    documentHash = 0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef;
  }

  function getDocumentHash() public view returns (bytes32) {
    return documentHash;
  }
}

Referenstyper förklarade

Till skillnad från värdetyper lagrar referenstyper inte datan direkt. I stället lagrar de en referens (en minnesadress) till den plats där datan finns.

Det innebär att om du tilldelar en variabel av en referenstyp pekar båda variablerna på samma data. Ändringar som görs genom den ena variabeln syns genom den andra.

Strängar för text

Typen string används för textdata. Det är en dynamisk array av byte som lagrar UTF-8-kodade tecken.

Eftersom storleken kan ändras räknas string som en referenstyp. Du ser ofta memory eller calldata tillsammans med strängar i funktionsparametrar eller returtyper.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract Greeter {
  string public currentMessage = "Hello, CoddyKit!";

  function setMessage(string memory _newMessage) public {
    currentMessage = _newMessage;
  }

  function getMessage() public view returns (string memory) {
    return currentMessage;
  }
}

Dynamiska byte och arrayer

Solidity erbjuder dynamiska datastrukturer:

bytes: En bytearray med dynamisk storlek. Liknar string, men används för rå byte-data.
Arrayer (T[] eller T[k]): Kan innehålla en sekvens av element av samma typ T. De kan ha fast storlek (T[k], där k är längden) eller vara dynamiska (T[]).

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract DataCollection {
  bytes public rawData = hex"1a2b3c"; // Dynamic bytes
  uint[] public dynamicNumbers; // Dynamic array of uints
  bool[2] public fixedBooleans = [true, false]; // Fixed-size array

  constructor() {
    dynamicNumbers.push(10);
    dynamicNumbers.push(20);
  }

  function getRawData() public view returns (bytes memory) {
    return rawData;
  }

  function getDynamicNumbersCount() public view returns (uint) {
    return dynamicNumbers.length;
  }
}

Anpassade data med structs

Ibland behöver du gruppera relaterad data. Då är structs praktiska!

En struct låter dig definiera en egen anpassad datatyp genom att kombinera flera variabler av olika typer. Tänk på det som att skapa en ritning för en post.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract UserProfile {
  struct User {
    uint id;
    address userAddress;
    string name;
    bool isActive;
  }

  User public adminUser;

  constructor() {
    adminUser = User(1, msg.sender, "Alice", true);
  }

  function getAdminName() public view returns (string memory) {
    return adminUser.name;
  }
}

Deklarera och initiera

Det är enkelt att deklarera en variabel: DataType visibility variableName;

Om du inte initierar en variabel uttryckligen tilldelar Solidity den ett standardvärde:

bool: false
uint/int: 0
address: 0x00...00 (nolladress)
string/bytes/arrayer: Tomt värde

Det är god praxis att initiera variabler uttryckligen när de deklareras.

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

contract VariableLife {
  // Declared without explicit initialization (gets default values)
  uint public defaultBalance;
  bool public defaultStatus;

  // Declared and initialized
  uint public initialBalance = 1000;
  string public greeting = "Hello";

  function getDefaults() public view returns (uint, bool) {
    return (defaultBalance, defaultStatus);
  }
}

Utmaning om datatyper

Testa dina kunskaper om Soliditys datatyper!

Besvara frågan i den interaktiva lektionen

Sammanfattning av lektionen

Utmärkt! I den här lektionen har du lärt dig om de grundläggande datatyperna i Solidity:

Värdetyper (till exempel bool, uint, address, fasta bytesX) lagrar data direkt och kopieras vid tilldelning.
Referenstyper (till exempel string, dynamiska bytes, arrays, structs) lagrar en referens till data, vilket gör att flera variabler kan peka på samma information.
Du har också lärt dig att deklarera och initiera variabler och förstått deras standardvärden.

Nästa steg är att gå igenom hur du styr flödet i dina smarta kontrakt!

Gratis att börja

Lär dig Smarta blockkedjekontrakt med Solidity med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 12
Lektioner: 48

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Datatyper och variabler i Solidity” gratis?

Ja – hela texten till ”Datatyper och variabler i Solidity” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Smarta blockkedjekontrakt med Solidity, kan Ni uppgradera till CoddyKit PRO. Kursen i Smarta blockkedjekontrakt med Solidity innehåller totalt 4 lektioner.

Vad lär jag mig i ”Datatyper och variabler i Solidity”?

Lär er om värdetyper och referenstyper samt hur variabler deklareras och initieras i Solidity. Ni övar på Smarta blockkedjekontrakt med Solidity med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Smarta blockkedjekontrakt med Solidity?

Du behöver inga förkunskaper. Utbildningen i Smarta blockkedjekontrakt med Solidity på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Datatyper och variabler i Solidity”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Smarta blockkedjekontrakt med Solidity-lektionen?

Ja. Varje Smarta blockkedjekontrakt med Solidity-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Smarta blockkedjekontrakt med Solidity