{"id":1096,"date":"2026-08-17T05:37:56","date_gmt":"2026-08-17T05:37:56","guid":{"rendered":"https:\/\/www.devopsschool.com\/tutorials\/?p=1096"},"modified":"2026-08-17T05:37:57","modified_gmt":"2026-08-17T05:37:57","slug":"go-tutorials-numeric-types-beginner-tutorial","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/tutorials\/go-tutorials-numeric-types-beginner-tutorial\/","title":{"rendered":"Go Tutorials: Numeric Types Beginner Tutorial"},"content":{"rendered":"\n

<\/p>\n\n\n\n

Go has four main families of numeric types:<\/p>\n\n\n\n

Numbers\n\u2502\n\u251c\u2500\u2500 Signed Integers\n\u2502   \u251c\u2500\u2500 int\n\u2502   \u251c\u2500\u2500 int8\n\u2502   \u251c\u2500\u2500 int16\n\u2502   \u251c\u2500\u2500 int32\n\u2502   \u2514\u2500\u2500 int64\n\u2502\n\u251c\u2500\u2500 Unsigned Integers\n\u2502   \u251c\u2500\u2500 uint\n\u2502   \u251c\u2500\u2500 uint8\n\u2502   \u251c\u2500\u2500 uint16\n\u2502   \u251c\u2500\u2500 uint32\n\u2502   \u2514\u2500\u2500 uint64\n\u2502\n\u251c\u2500\u2500 Floating Point\n\u2502   \u251c\u2500\u2500 float32\n\u2502   \u2514\u2500\u2500 float64\n\u2502\n\u2514\u2500\u2500 Complex Numbers\n    \u251c\u2500\u2500 complex64\n    \u2514\u2500\u2500 complex128<\/code><\/pre>\n\n\n\n
The simplest way to remember them is:<\/p>\n\n\n\n
Type family<\/th>Stores<\/th>Example<\/th><\/tr><\/thead>
int<\/code><\/td>Whole numbers, positive or negative<\/td>-10<\/code>, 0<\/code>, 25<\/code><\/td><\/tr>
uint<\/code><\/td>Whole numbers, zero or positive<\/td>0<\/code>, 25<\/code>, 100<\/code><\/td><\/tr>
float<\/code><\/td>Decimal numbers<\/td>10.5<\/code>, 3.14<\/code><\/td><\/tr>
complex<\/code><\/td>Real + imaginary numbers<\/td>3 + 4i<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\n
1. Signed Integers<\/h1>\n\n\n\n
A signed integer<\/strong> can contain:<\/p>\n\n\n\n
negative numbers\nzero\npositive numbers<\/code><\/pre>\n\n\n\n
Example:<\/p>\n\n\n\n
var temperature int = -10<\/code><\/pre>\n\n\n\n
Here -10<\/code> is allowed because int<\/code> is signed<\/strong>.<\/p>\n\n\n\n
Signed integer types<\/h2>\n\n\n\n
Type<\/th>Size<\/th>Approximate range<\/th><\/tr><\/thead>
int8<\/code><\/td>8 bits<\/td>-128 to 127<\/td><\/tr>
int16<\/code><\/td>16 bits<\/td>-32,768 to 32,767<\/td><\/tr>
int32<\/code><\/td>32 bits<\/td>-2.1 billion to +2.1 billion<\/td><\/tr>
int64<\/code><\/td>64 bits<\/td>Very large<\/td><\/tr>
int<\/code><\/td>32 or 64 bits<\/td>Depends on system<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
For most normal programming, use:<\/p>\n\n\n\n
int<\/code><\/pre>\n\n\n\n
Example<\/h3>\n\n\n\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n    var age int = 40\n    var temperature int = -5\n    var balance int = -1000\n\n    fmt.Println(\"Age:\", age)\n    fmt.Println(\"Temperature:\", temperature)\n    fmt.Println(\"Balance:\", balance)\n}<\/code><\/pre>\n\n\n\n
Output:<\/p>\n\n\n\n
Age: 40\nTemperature: -5\nBalance: -1000<\/code><\/pre>\n\n\n\n
When should I use int<\/code>?<\/h2>\n\n\n\n
Use int<\/code> for normal whole-number calculations.<\/p>\n\n\n\n
Typical use cases:<\/p>\n\n\n\n
age := 40\nusers := 500\nitems := 10\ntemperature := -5\nscore := 95<\/code><\/pre>\n\n\n\n
For example, loop counters normally use int<\/code>:<\/p>\n\n\n\n
for i := 0; i < 10; i++ {\n    fmt.Println(i)\n}<\/code><\/pre>\n\n\n\n
Simple rule<\/h3>\n\n\n\n
\n
If you need a normal whole number and don’t have a special requirement, use int<\/code>.<\/p>\n<\/blockquote>\n\n\n\n
\n\n\n\n
2. int8<\/code><\/h1>\n\n\n\n
int8<\/code> is a very small signed integer.<\/p>\n\n\n\n
var temperature int8 = -20<\/code><\/pre>\n\n\n\n
Range:<\/p>\n\n\n\n
-128 to 127<\/code><\/pre>\n\n\n\n
Example:<\/p>\n\n\n\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n    var temperature int8 = -20\n\n    fmt.Println(temperature)\n}<\/code><\/pre>\n\n\n\n
Use cases<\/h3>\n\n\n\n
You may use int8<\/code> when:<\/p>\n\n\n\n
    \n
  • Memory layout matters<\/li>\n\n\n\n
  • Reading binary data<\/li>\n\n\n\n
  • Working with low-level protocols<\/li>\n\n\n\n
  • Interacting with hardware<\/li>\n<\/ul>\n\n\n\n
    For normal application development, you usually do not<\/strong> need int8<\/code>.<\/p>\n\n\n\n
    \n\n\n\n
    3. int16<\/code><\/h1>\n\n\n\n
    Range:<\/p>\n\n\n\n
    -32768 to 32767<\/code><\/pre>\n\n\n\n
    Example:<\/p>\n\n\n\n
    var altitude int16 = -500<\/code><\/pre>\n\n\n\n
    Possible use cases:<\/p>\n\n\n\n
      \n
    • Binary file formats<\/li>\n\n\n\n
    • Network protocols<\/li>\n\n\n\n
    • Hardware data<\/li>\n\n\n\n
    • Memory-sensitive structures<\/li>\n<\/ul>\n\n\n\n
      Again, normal application code usually uses int<\/code>.<\/p>\n\n\n\n
      \n\n\n\n
      4. int32<\/code><\/h1>\n\n\n\n
      Example:<\/p>\n\n\n\n
      var population int32 = 1000000<\/code><\/pre>\n\n\n\n
      One very important use of int32<\/code> in Go is Unicode characters.<\/p>\n\n\n\n
      Go has an alias:<\/p>\n\n\n\n
      rune = int32<\/code><\/pre>\n\n\n\n
      For example:<\/p>\n\n\n\n
      package main\n\nimport \"fmt\"\n\nfunc main() {\n    var letter rune = 'A'\n\n    fmt.Println(letter)\n    fmt.Printf(\"%c\\n\", letter)\n}<\/code><\/pre>\n\n\n\n
      Output:<\/p>\n\n\n\n
      65\nA<\/code><\/pre>\n\n\n\n
      So:<\/p>\n\n\n\n
      rune\n \u2193\nint32\n \u2193\nUnicode character<\/code><\/pre>\n\n\n\n
      \n\n\n\n
      5. int64<\/code><\/h1>\n\n\n\n
      int64<\/code> can store very large whole numbers.<\/p>\n\n\n\n
      Example:<\/p>\n\n\n\n
      var population int64 = 8000000000<\/code><\/pre>\n\n\n\n
      Use cases include:<\/p>\n\n\n\n
        \n
      • Very large counters<\/li>\n\n\n\n
      • Unix timestamps<\/li>\n\n\n\n
      • Database IDs<\/li>\n\n\n\n
      • File sizes<\/li>\n\n\n\n
      • Large financial quantities expressed in smallest units<\/li>\n<\/ul>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc main() {\n    var fileSize int64 = 5_000_000_000\n\n    fmt.Println(fileSize)\n}<\/code><\/pre>\n\n\n\n
        Notice this:<\/p>\n\n\n\n
        5_000_000_000<\/code><\/pre>\n\n\n\n
        Go allows _<\/code> to make large numbers easier to read.<\/p>\n\n\n\n
        It is the same as:<\/p>\n\n\n\n
        5000000000<\/code><\/pre>\n\n\n\n
        \n\n\n\n
        6. Unsigned Integers<\/h1>\n\n\n\n
        Unsigned integers cannot contain negative numbers<\/strong>.<\/p>\n\n\n\n
        Signed:\n\n-10  -5  0  5  10\n\n\nUnsigned:\n\n0  5  10  100<\/code><\/pre>\n\n\n\n
        Example:<\/p>\n\n\n\n
        var users uint = 100<\/code><\/pre>\n\n\n\n
        This works.<\/p>\n\n\n\n
        But:<\/p>\n\n\n\n
        var users uint = -100<\/code><\/pre>\n\n\n\n
        doesn’t work because uint<\/code> cannot represent negative values.<\/p>\n\n\n\n
        Unsigned integer types<\/h2>\n\n\n\n
        Type<\/th>Minimum<\/th>Maximum<\/th><\/tr><\/thead>
        uint8<\/code><\/td>0<\/td>255<\/td><\/tr>
        uint16<\/code><\/td>0<\/td>65,535<\/td><\/tr>
        uint32<\/code><\/td>0<\/td>~4.29 billion<\/td><\/tr>
        uint64<\/code><\/td>0<\/td>Very large<\/td><\/tr>
        uint<\/code><\/td>0<\/td>System dependent<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
        \n\n\n\n
        7. uint<\/code><\/h1>\n\n\n\n
        Example:<\/p>\n\n\n\n
        package main\n\nimport \"fmt\"\n\nfunc main() {\n    var numberOfUsers uint = 500\n\n    fmt.Println(numberOfUsers)\n}<\/code><\/pre>\n\n\n\n
        Use cases can include values that are inherently non-negative.<\/p>\n\n\n\n
        For example:<\/p>\n\n\n\n
        bit manipulation\nbinary protocols\nhardware registers\nmemory-related values<\/code><\/pre>\n\n\n\n
        But here’s an important Go practice:<\/p>\n\n\n\n
        \n
        Don’t automatically use uint<\/code> just because a value cannot logically be negative.<\/p>\n<\/blockquote>\n\n\n\n
        For example, for the number of students:<\/p>\n\n\n\n
        students := 50<\/code><\/pre>\n\n\n\n
        Using int<\/code> is normally easier.<\/p>\n\n\n\n
        \n\n\n\n
        8. uint8<\/code><\/h1>\n\n\n\n
        uint8<\/code> has an important role in Go.<\/p>\n\n\n\n
        Range:<\/p>\n\n\n\n
        0 \u2192 255<\/code><\/pre>\n\n\n\n
        Go has an alias:<\/p>\n\n\n\n
        byte = uint8<\/code><\/pre>\n\n\n\n
        Therefore:<\/p>\n\n\n\n
        var x byte = 65<\/code><\/pre>\n\n\n\n
        is essentially:<\/p>\n\n\n\n
        var x uint8 = 65<\/code><\/pre>\n\n\n\n
        This is why byte arrays are common when working with:<\/p>\n\n\n\n
          \n
        • Files<\/li>\n\n\n\n
        • Network data<\/li>\n\n\n\n
        • Images<\/li>\n\n\n\n
        • Strings<\/li>\n\n\n\n
        • Raw binary data<\/li>\n<\/ul>\n\n\n\n
          Example:<\/p>\n\n\n\n
          package main\n\nimport \"fmt\"\n\nfunc main() {\n    var value uint8 = 255\n    var letter byte = 'A'\n\n    fmt.Println(value)\n    fmt.Println(letter)\n}<\/code><\/pre>\n\n\n\n
          Output:<\/p>\n\n\n\n
          255\n65<\/code><\/pre>\n\n\n\n
          Remember:<\/p>\n\n\n\n
          byte\n \u2193\nuint8\n \u2193\n0-255<\/code><\/pre>\n\n\n\n
          \n\n\n\n
          9. Floating-Point Numbers<\/h1>\n\n\n\n
          Integers cannot store decimal fractions.<\/p>\n\n\n\n
          For example:<\/p>\n\n\n\n
          10\n20\n-5<\/code><\/pre>\n\n\n\n
          are integers.<\/p>\n\n\n\n
          But:<\/p>\n\n\n\n
          10.5\n3.14\n99.99<\/code><\/pre>\n\n\n\n
          are floating-point numbers.<\/p>\n\n\n\n
          Go provides:<\/p>\n\n\n\n
          float32\nfloat64<\/code><\/pre>\n\n\n\n
          \n\n\n\n
          10. float32<\/code><\/h1>\n\n\n\n
          float32<\/code> uses 32 bits.<\/p>\n\n\n\n
          Example:<\/p>\n\n\n\n
          package main\n\nimport \"fmt\"\n\nfunc main() {\n    var temperature float32 = 36.5\n\n    fmt.Println(temperature)\n}<\/code><\/pre>\n\n\n\n
          Typical use cases:<\/p>\n\n\n\n
            \n
          • Graphics<\/li>\n\n\n\n
          • Games<\/li>\n\n\n\n
          • Scientific data where 32-bit precision is sufficient<\/li>\n\n\n\n
          • Large arrays where memory usage matters<\/li>\n\n\n\n
          • APIs\/libraries requiring 32-bit floats<\/li>\n<\/ul>\n\n\n\n
            For ordinary Go applications, however, float64<\/code> is usually preferred.<\/p>\n\n\n\n
            \n\n\n\n
            11. float64<\/code><\/h1>\n\n\n\n
            float64<\/code> provides much higher precision.<\/p>\n\n\n\n
            Example:<\/p>\n\n\n\n
            package main\n\nimport \"fmt\"\n\nfunc main() {\n    var price float64 = 199.99\n    var pi float64 = 3.141592653589793\n\n    fmt.Println(\"Price:\", price)\n    fmt.Println(\"Pi:\", pi)\n}<\/code><\/pre>\n\n\n\n
            Use cases:<\/p>\n\n\n\n
            measurements\npercentages\nstatistics\nscientific calculations\ncoordinates\naverages\ngeneral decimal calculations<\/code><\/pre>\n\n\n\n
            Important<\/h3>\n\n\n\n
            When you write:<\/p>\n\n\n\n
            price := 99.99<\/code><\/pre>\n\n\n\n
            Go normally infers:<\/p>\n\n\n\n
            float64<\/code><\/pre>\n\n\n\n
            So:<\/p>\n\n\n\n
            price := 99.99<\/code><\/pre>\n\n\n\n
            is effectively similar to:<\/p>\n\n\n\n
            var price float64 = 99.99<\/code><\/pre>\n\n\n\n
            Beginner rule<\/h3>\n\n\n\n
            \n
            Use float64<\/code> unless you specifically need float32<\/code>.<\/p>\n<\/blockquote>\n\n\n\n
            \n\n\n\n
            12. Be Careful Using Floats for Money<\/h1>\n\n\n\n
            This looks natural:<\/p>\n\n\n\n
            price := 10.99<\/code><\/pre>\n\n\n\n
            But floating-point numbers cannot represent every decimal value perfectly.<\/p>\n\n\n\n
            For example:<\/p>\n\n\n\n
            package main\n\nimport \"fmt\"\n\nfunc main() {\n    result := 0.1 + 0.2\n\n    fmt.Printf(\"%.20f\\n\", result)\n}<\/code><\/pre>\n\n\n\n
            You may see something like:<\/p>\n\n\n\n
            0.30000000000000004441<\/code><\/pre>\n\n\n\n
            Therefore, for exact money calculations, applications commonly store money in the smallest currency unit.<\/p>\n\n\n\n
            Instead of:<\/p>\n\n\n\n
            price := 10.99<\/code><\/pre>\n\n\n\n
            you might store:<\/p>\n\n\n\n
            priceInCents := 1099<\/code><\/pre>\n\n\n\n
            or for Indian rupees:<\/p>\n\n\n\n
            priceInPaise := 1099<\/code><\/pre>\n\n\n\n
            representing:<\/p>\n\n\n\n
            \u20b910.99<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            13. Complex Numbers<\/h1>\n\n\n\n
            Go also supports complex numbers.<\/p>\n\n\n\n
            A complex number consists of:<\/p>\n\n\n\n
            real part + imaginary part<\/code><\/pre>\n\n\n\n
            Example:<\/p>\n\n\n\n
            3 + 4i<\/code><\/pre>\n\n\n\n
            Here:<\/p>\n\n\n\n
            3 = real part\n4 = imaginary part\ni = imaginary unit<\/code><\/pre>\n\n\n\n
            Go has:<\/p>\n\n\n\n
            complex64\ncomplex128<\/code><\/pre>\n\n\n\n
            \n\n\n\n
            14. complex64<\/code><\/h1>\n\n\n\n
            complex64<\/code> consists approximately of:<\/p>\n\n\n\n
            float32 + float32<\/code><\/pre>\n\n\n\n
            Example:<\/p>\n\n\n\n
            package main\n\nimport \"fmt\"\n\nfunc main() {\n    var number complex64 = 3 + 4i\n\n    fmt.Println(number)\n}<\/code><\/pre>\n\n\n\n
            Output:<\/p>\n\n\n\n
            (3+4i)<\/code><\/pre>\n\n\n\n
            Typical use cases:<\/p>\n\n\n\n
              \n
            • Signal processing<\/li>\n\n\n\n
            • Electrical engineering<\/li>\n\n\n\n
            • Scientific calculations<\/li>\n\n\n\n
            • Fourier transforms<\/li>\n\n\n\n
            • Mathematical simulations<\/li>\n<\/ul>\n\n\n\n
              Most normal web\/backend programs never need this type.<\/p>\n\n\n\n
              \n\n\n\n
              15. complex128<\/code><\/h1>\n\n\n\n
              complex128<\/code> uses greater precision.<\/p>\n\n\n\n
              Conceptually:<\/p>\n\n\n\n
              complex128\n    \u2502\n    \u251c\u2500\u2500 float64 real part\n    \u2502\n    \u2514\u2500\u2500 float64 imaginary part<\/code><\/pre>\n\n\n\n
              Example:<\/p>\n\n\n\n
              package main\n\nimport \"fmt\"\n\nfunc main() {\n    var number complex128 = 3 + 4i\n\n    fmt.Println(\"Number:\", number)\n    fmt.Println(\"Real:\", real(number))\n    fmt.Println(\"Imaginary:\", imag(number))\n}<\/code><\/pre>\n\n\n\n
              Output:<\/p>\n\n\n\n
              Number: (3+4i)\nReal: 3\nImaginary: 4<\/code><\/pre>\n\n\n\n
              Go provides built-in functions:<\/p>\n\n\n\n
              real()\nimag()\ncomplex()<\/code><\/pre>\n\n\n\n
              For example:<\/p>\n\n\n\n
              x := complex(3.0, 4.0)<\/code><\/pre>\n\n\n\n
              creates:<\/p>\n\n\n\n
              3 + 4i<\/code><\/pre>\n\n\n\n
              \n\n\n\n
              16. One Complete Example<\/h1>\n\n\n\n
              This example demonstrates all four major families.<\/p>\n\n\n\n
              package main\n\nimport \"fmt\"\n\nfunc main() {\n\n    \/\/ --------------------------------\n    \/\/ 1. SIGNED INTEGER\n    \/\/ --------------------------------\n\n    \/\/ Can store negative and positive whole numbers.\n    var temperature int = -10\n\n    \/\/ --------------------------------\n    \/\/ 2. UNSIGNED INTEGER\n    \/\/ --------------------------------\n\n    \/\/ Can store only zero or positive whole numbers.\n    var packetValue uint = 255\n\n    \/\/ --------------------------------\n    \/\/ 3. FLOATING POINT\n    \/\/ --------------------------------\n\n    \/\/ Can store decimal numbers.\n    var price float64 = 199.99\n\n    \/\/ --------------------------------\n    \/\/ 4. COMPLEX NUMBER\n    \/\/ --------------------------------\n\n    \/\/ Stores real + imaginary values.\n    var signal complex128 = 3 + 4i\n\n    fmt.Println(\"Temperature:\", temperature)\n    fmt.Println(\"Packet value:\", packetValue)\n    fmt.Println(\"Price:\", price)\n    fmt.Println(\"Signal:\", signal)\n\n    fmt.Println(\"Signal real part:\", real(signal))\n    fmt.Println(\"Signal imaginary part:\", imag(signal))\n}<\/code><\/pre>\n\n\n\n
              Output:<\/p>\n\n\n\n
              Temperature: -10\nPacket value: 255\nPrice: 199.99\nSignal: (3+4i)\nSignal real part: 3\nSignal imaginary part: 4<\/code><\/pre>\n\n\n\n
              \n\n\n\n
              17. int<\/code> vs uint<\/code> vs float64<\/code> vs complex128<\/code><\/h1>\n\n\n\n
              This comparison is the most important part to remember.<\/p>\n\n\n\n
              Requirement<\/th>Best choice<\/th>Example<\/th><\/tr><\/thead>
              Normal whole number<\/td>int<\/code><\/td>40<\/code><\/td><\/tr>
              Negative whole number<\/td>int<\/code><\/td>-10<\/code><\/td><\/tr>
              Low-level non-negative integer<\/td>uint<\/code> family<\/td>255<\/code><\/td><\/tr>
              Raw byte<\/td>byte<\/code> \/ uint8<\/code><\/td>65<\/code><\/td><\/tr>
              Unicode character<\/td>rune<\/code> \/ int32<\/code><\/td>'\u4f60'<\/code><\/td><\/tr>
              Decimal number<\/td>float64<\/code><\/td>10.25<\/code><\/td><\/tr>
              Memory-sensitive decimal<\/td>float32<\/code><\/td>10.25<\/code><\/td><\/tr>
              Complex mathematics<\/td>complex128<\/code><\/td>3 + 4i<\/code><\/td><\/tr>
              Lower-precision complex number<\/td>complex64<\/code><\/td>3 + 4i<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
              \n\n\n\n
              18. Type Conversion<\/h1>\n\n\n\n
              Go does not<\/strong> automatically mix numeric types.<\/p>\n\n\n\n
              For example:<\/p>\n\n\n\n
              var x int = 10\nvar y float64 = 20.5<\/code><\/pre>\n\n\n\n
              You cannot simply do:<\/p>\n\n\n\n
              result := x + y<\/code><\/pre>\n\n\n\n
              because:<\/p>\n\n\n\n
              x = int\ny = float64<\/code><\/pre>\n\n\n\n
              You have to convert one type.<\/p>\n\n\n\n
              package main\n\nimport \"fmt\"\n\nfunc main() {\n    var x int = 10\n    var y float64 = 20.5\n\n    result := float64(x) + y\n\n    fmt.Println(result)\n}<\/code><\/pre>\n\n\n\n
              Output:<\/p>\n\n\n\n
              30.5<\/code><\/pre>\n\n\n\n
              Think:<\/p>\n\n\n\n
              x\n10\n\u2502\n\u2502 float64(x)\n\u25bc\n10.0\n     +\n20.5\n\u2500\u2500\u2500\u2500\u2500\n30.5<\/code><\/pre>\n\n\n\n
              \n\n\n\n
              19. Overflow<\/h1>\n\n\n\n
              Every numeric type has a limit.<\/p>\n\n\n\n
              For example:<\/p>\n\n\n\n
              uint8<\/code><\/pre>\n\n\n\n
              can only hold:<\/p>\n\n\n\n
              0 \u2192 255<\/code><\/pre>\n\n\n\n
              So this is invalid:<\/p>\n\n\n\n
              var x uint8 = 300<\/code><\/pre>\n\n\n\n
              because:<\/p>\n\n\n\n
              300 > 255<\/code><\/pre>\n\n\n\n
              Similarly:<\/p>\n\n\n\n
              int8<\/code><\/pre>\n\n\n\n
              supports:<\/p>\n\n\n\n
              -128 \u2192 127<\/code><\/pre>\n\n\n\n
              Therefore:<\/p>\n\n\n\n
              var x int8 = 200<\/code><\/pre>\n\n\n\n
              is invalid.<\/p>\n\n\n\n
              \n\n\n\n
              20. Special Aliases: byte<\/code> and rune<\/code><\/h1>\n\n\n\n
              Two names appear constantly in Go:<\/p>\n\n\n\n
              byte\nrune<\/code><\/pre>\n\n\n\n
              They aren’t entirely new numeric storage formats.<\/p>\n\n\n\n
              byte = uint8\nrune = int32<\/code><\/pre>\n\n\n\n
              Think of them as meaningful names:<\/p>\n\n\n\n
              Type<\/th>Actually<\/th>Meaning\/use<\/th><\/tr><\/thead>
              byte<\/code><\/td>uint8<\/code><\/td>Raw byte\/data<\/td><\/tr>
              rune<\/code><\/td>int32<\/code><\/td>Unicode character<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
              Example:<\/p>\n\n\n\n
              package main\n\nimport \"fmt\"\n\nfunc main() {\n    var b byte = 'A'\n    var r rune = '\u4f60'\n\n    fmt.Println(b)\n    fmt.Printf(\"%c\\n\", b)\n\n    fmt.Println(r)\n    fmt.Printf(\"%c\\n\", r)\n}<\/code><\/pre>\n\n\n\n
              \n\n\n\n
              21. Practical Real-World Examples<\/h1>\n\n\n\n
              Age<\/h3>\n\n\n\n
              age := 40<\/code><\/pre>\n\n\n\n
              Use:<\/p>\n\n\n\n
              int<\/code><\/pre>\n\n\n\n
              Number of users<\/h3>\n\n\n\n
              users := 1000<\/code><\/pre>\n\n\n\n
              Usually:<\/p>\n\n\n\n
              int<\/code><\/pre>\n\n\n\n
              Temperature<\/h3>\n\n\n\n
              temperature := -5<\/code><\/pre>\n\n\n\n
              Use:<\/p>\n\n\n\n
              int<\/code><\/pre>\n\n\n\n
              or if decimals are needed:<\/p>\n\n\n\n
              temperature := -5.7<\/code><\/pre>\n\n\n\n
              Use:<\/p>\n\n\n\n
              float64<\/code><\/pre>\n\n\n\n
              Height<\/h3>\n\n\n\n
              height := 175.5<\/code><\/pre>\n\n\n\n
              Use:<\/p>\n\n\n\n
              float64<\/code><\/pre>\n\n\n\n
              File size<\/h3>\n\n\n\n
              var size int64 = 10_000_000_000<\/code><\/pre>\n\n\n\n
              int64<\/code> can be useful.<\/p>\n\n\n\n
              Network byte<\/h3>\n\n\n\n
              var packetByte byte = 255<\/code><\/pre>\n\n\n\n
              Use:<\/p>\n\n\n\n
              byte \/ uint8<\/code><\/pre>\n\n\n\n
              Unicode character<\/h3>\n\n\n\n
              var character rune = '\u65e5'<\/code><\/pre>\n\n\n\n
              Use:<\/p>\n\n\n\n
              rune \/ int32<\/code><\/pre>\n\n\n\n
              Scientific complex value<\/h3>\n\n\n\n
              var signal complex128 = 2.5 + 3.7i<\/code><\/pre>\n\n\n\n
              Use:<\/p>\n\n\n\n
              complex128<\/code><\/pre>\n\n\n\n
              \n\n\n\n
              22. The Rule You Should Remember<\/h1>\n\n\n\n
              As a beginner, don’t overthink all the numeric types.<\/p>\n\n\n\n
              For approximately 90% of normal Go application code<\/strong>, think:<\/p>\n\n\n\n
              Whole number\n     \u2193\n    int\n\n\nDecimal number\n     \u2193\n  float64\n\n\nRaw data \/ bytes\n     \u2193\n byte \/ uint8\n\n\nUnicode character\n     \u2193\n rune \/ int32\n\n\nComplex mathematics\n     \u2193\n complex128<\/code><\/pre>\n\n\n\n
              And only deliberately choose:<\/p>\n\n\n\n
              int8\nint16\nuint16\nfloat32\ncomplex64\n...<\/code><\/pre>\n\n\n\n
              when you have a specific reason such as memory layout, binary protocols, hardware, APIs, or scientific requirements.<\/p>\n\n\n\n
              Final Cheat Sheet<\/h2>\n\n\n\n
              \/\/ Normal whole number\nage := 40                    \/\/ int\n\n\/\/ Negative whole number\ntemperature := -10           \/\/ int\n\n\/\/ Decimal\nprice := 99.99               \/\/ float64\n\n\/\/ Large integer\nvar size int64 = 5_000_000_000\n\n\/\/ Raw byte\nvar data byte = 255          \/\/ byte = uint8\n\n\/\/ Unicode character\nvar letter rune = '\u65e5'       \/\/ rune = int32\n\n\/\/ Unsigned low-level number\nvar flags uint32 = 100\n\n\/\/ Complex mathematics\nvar signal complex128 = 3 + 4i<\/code><\/pre>\n\n\n\n
              The most useful mental model is simply:<\/p>\n\n\n\n
              int<\/code> = whole numbers \u2192 float64<\/code> = decimal numbers \u2192 byte<\/code> = raw data \u2192 rune<\/code> = characters \u2192 complex128<\/code> = complex mathematics.<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
              Go has four main families of numeric types: The simplest way to remember them is: Type family Stores Example int Whole numbers, positive or negative -10, 0,… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1096","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1096","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/comments?post=1096"}],"version-history":[{"count":1,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1096\/revisions"}],"predecessor-version":[{"id":1097,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1096\/revisions\/1097"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/media?parent=1096"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/categories?post=1096"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/tags?post=1096"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}