<\/p>\n
Updated July 2, 2026.<\/strong> Refreshed for Go 1.22+ and current SEO best practices.<\/p>\n<\/div>\n In this lesson we cover the Go variables tutorial<\/strong> essentials \u2014 how to declare variables, choose types, work with constants, and print formatted output. If you completed Lesson 3 \u2013 Go Basic Syntax<\/a>, you already know the skeleton of a Go program. Here we add the data layer: names, types, and values that make programs useful.<\/p>\n Prerequisites:<\/strong> Go 1.22 or newer installed ( The When you omit the initial value, Go assigns the zero value<\/strong> for that type (covered later). When you omit the type but provide a value, Go infers the type from the literal. Use Inside functions, the Important rules for If you are coming from Python<\/a>, think of Constants are values that cannot change after compilation. Declare them with Constants must be compile-time values \u2014 numbers, strings, or boolean literals. You cannot assign the result of a function call to a Go provides a small set of built-in types. Understanding them early prevents bugs when you mix integers, floats, and strings:<\/p>\n Start with Every type in Go has a default value when you declare a variable without initializing it:<\/p>\n Zero values mean Go never leaves variables in an undefined state \u2014 a safety feature compared to languages where uninitialized variables contain garbage. You will rely on zero values often when declaring structs and slices in later lessons.<\/p>\n Go does not<\/strong> perform implicit numeric conversions. You must convert explicitly:<\/p>\n Syntax is Common verbs: You now understand Go variables and types<\/strong>: Continue the series: Lesson 1 \u2013 Introduction<\/a> \u00b7 Lesson 2 \u2013 Setup<\/a> \u00b7 Lesson 3 \u2013 Basic Syntax<\/a> \u00b7 Lesson 5 \u2013 Control Flow<\/a><\/p>\n Browse all tutorials: Content Directory<\/a> \u00b7 Go Programming Hub<\/a><\/p>\n What is the difference between var and := in Go?<\/strong> Does Go have implicit type conversion?<\/strong> What are zero values in Go?<\/strong> <\/p>\ngo version<\/code> in your terminal) and familiarity with Go Programming \u2013 Setup<\/a> and Go Basic Syntax<\/a>. Estimated time:<\/strong> 35\u201345 minutes.<\/p>\n1. Declaring Variables with var<\/h4>\n
var<\/code> keyword declares a variable and optionally assigns an initial value. You can declare one variable at a time or group several in a single block:<\/p>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar name string\n\tname = \"Kindson\"\n\n\tvar age int = 30\n\tvar city = \"Lagos\" \/\/ type inferred as string\n\n\tvar (\n\t\tlanguage = \"Go\"\n\t\tyear = 2026\n\t)\n\n\tfmt.Println(name, age, city, language, year)\n}\n<\/code><\/pre>\nvar<\/code> at package level or when you want an explicit type that inference might not capture cleanly.<\/p>\n2. Short Variable Declaration with :=<\/h4>\n
:=<\/code> operator is the most common way to declare and initialize a variable in one step:<\/p>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tmessage := \"Hello from Go\"\n\tcount := 42\n\tpi := 3.14159\n\tisReady := true\n\n\tfmt.Println(message, count, pi, isReady)\n}\n<\/code><\/pre>\n:=<\/code>:<\/p>\n\n
:=<\/code> if one name is new: count, err := doWork()<\/code>.<\/li>\nx := int<\/code> without a value.<\/li>\n<\/ul>\n:=<\/code> as similar to a first assignment that also creates the name \u2014 but Go is statically typed, so the type is fixed at declaration.<\/p>\n3. Constants<\/h4>\n
const<\/code>:<\/p>\npackage main\n\nimport \"fmt\"\n\nconst AppName = \"KindsonGo\"\nconst MaxUsers = 1000\n\nconst (\n\tStatusOK = 200\n\tStatusError = 500\n)\n\nfunc main() {\n\tfmt.Println(AppName, MaxUsers, StatusOK)\n}\n<\/code><\/pre>\nconst<\/code>. For configuration that never changes (API version, buffer size, status codes), constants keep intent clear and prevent accidental reassignment.<\/p>\n4. Basic Types in Go<\/h4>\n
\n\n
\n \nCategory<\/th>\n Type<\/th>\n Example<\/th>\n Notes<\/th>\n<\/tr>\n<\/thead>\n \n Boolean<\/td>\n bool<\/code><\/td>\ntrue<\/code>, false<\/code><\/td>\nUsed in conditions and logic<\/td>\n<\/tr>\n \n String<\/td>\n string<\/code><\/td>\n\"hello\"<\/code><\/td>\nUTF-8 text; immutable<\/td>\n<\/tr>\n \n Integer<\/td>\n int<\/code>, int8<\/code>\u2026int64<\/code><\/td>\n42<\/code>, -7<\/code><\/td>\nint<\/code> size depends on platform (32 or 64 bit)<\/td>\n<\/tr>\n\n Unsigned<\/td>\n uint<\/code>, byte<\/code> (uint8<\/code>)<\/td>\n255<\/code><\/td>\nNon-negative only<\/td>\n<\/tr>\n \n Floating<\/td>\n float32<\/code>, float64<\/code><\/td>\n3.14<\/code><\/td>\nDefault untyped float is float64<\/code><\/td>\n<\/tr>\n\n Complex<\/td>\n complex64<\/code>, complex128<\/code><\/td>\n1+2i<\/code><\/td>\nRare in everyday code<\/td>\n<\/tr>\n \n Rune<\/td>\n rune<\/code> (int32<\/code>)<\/td>\n'A'<\/code>, '\u4e16'<\/code><\/td>\nRepresents a Unicode code point<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n int<\/code>, float64<\/code>, string<\/code>, and bool<\/code> for most programs. Reach for sized types (int32<\/code>, uint8<\/code>) when you care about memory layout or interoperability with other systems.<\/p>\n5. Zero Values<\/h4>\n
\n
0<\/code> for numeric types<\/li>\nfalse<\/code> for bool<\/code><\/li>\n\"\"<\/code> (empty string) for string<\/code><\/li>\nnil<\/code> for pointers, slices, maps, channels, interfaces, and function types<\/li>\n<\/ul>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar count int\n\tvar name string\n\tvar active bool\n\n\tfmt.Printf(\"count=%d, name=%q, active=%t\\n\", count, name, active)\n\t\/\/ Output: count=0, name=\"\", active=false\n}\n<\/code><\/pre>\n6. Type Conversion<\/h4>\n
package main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar i int = 42\n\tvar f float64 = float64(i)\n\tvar u uint = uint(f)\n\n\tvar x int32 = 10\n\tvar y int64 = int64(x) + 50\n\n\tfmt.Println(i, f, u, y)\n}\n<\/code><\/pre>\nType(value)<\/code> \u2014 for example int64(x)<\/code> or string(65)<\/code> for rune-to-string (not for arbitrary int-to-string; use strconv<\/code> for that). Mixing int<\/code> and float64<\/code> without conversion is a compile error, which catches precision bugs early.<\/p>\n7. Formatted Output with fmt.Printf<\/h4>\n
fmt.Println<\/code> prints values with spaces; fmt.Printf<\/code> gives you control over format using verbs<\/strong>:<\/p>\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\tname := \"Ada\"\n\tscore := 98.6\n\tpassed := true\n\n\tfmt.Printf(\"Name: %s\\n\", name)\n\tfmt.Printf(\"Score: %.1f\\n\", score)\n\tfmt.Printf(\"Passed: %t\\n\", passed)\n\tfmt.Printf(\"Type of score: %T\\n\", score)\n}\n<\/code><\/pre>\n%s<\/code> string, %d<\/code> integer, %f<\/code> float, %t<\/code> boolean, %v<\/code> default format, %T<\/code> type, %q<\/code> quoted string. Add \\n<\/code> for a newline \u2014 Printf<\/code> does not add one automatically. For quick debugging, fmt.Printf(\"%+v\\n\", someValue)<\/code> is handy with structs later.<\/p>\n8. Next Steps<\/h4>\n
var<\/code>, :=<\/code>, constants, basic types, zero values, type conversion, and fmt.Printf<\/code>. In the next lesson we cover control flow<\/strong> \u2014 if<\/code>, switch<\/code>, and for<\/code> loops that branch and repeat logic based on your data.<\/p>\nFrequently Asked Questions<\/h4>\n
\nvar<\/code> works at package level and inside functions; you can declare without a value. :=<\/code> only works inside functions and requires an initial value while inferring the type.<\/p>\n
\nNo. You must convert between types explicitly with syntax like float64(myInt)<\/code>. This prevents silent precision loss and unexpected behavior.<\/p>\n
\nZero values are defaults assigned when you declare a variable without initialization: 0<\/code> for numbers, false<\/code> for booleans, \"\"<\/code> for strings, and nil<\/code> for reference types.<\/p>\n