Packages
Every Go program consists of packages
. Each package needs to be imported first to use its exported identifiers.
You can import packages
like the code below.
package main
import (
"fmt" // Imported Package
"math/rand" // Imported Package
)
func main(){
fmt.Println("My journey of Go", rand.Intn(10)) //=>My journey of Go 1
}
You can also import each package individually.
import "fmt"
import "math/rand"
Exported names
In Go, a name is exported if it begins with a capital letter. For instance, Pi
is a name that is exported from 'math'
package.
package main
import "math"
func main(){
fmt.Println(math.Pi) //=> 3.141592653589793
}
Functions
A function can take zero or more arguments. You can define a function like the code below.
func name_of_the_function(arguments) type {
[content of the function]
}
Don't forget to write the types of arguments and the return value of a function.
package main
import "fmt"
func main(){
fmt.Println(greetings("John")) //=> Hello John
}
func greetings(name string) string {
return "Hello" + " " + name
}
Omission of the type of arguments
When there are two or more parameters sharing the same type, you only have to write the type once.
package main
import "fmt"
func main(){
fmt.Println(add(2, 4)) //=> 6
}
func add(x, y int) int {
return x + y
}
Multiple results
A function can return any number of results.
package main
import "fmt"
func main(){
a, b := multipleArgs("Hello", "World")
fmt.Println(a, b) //=> World Hello
}
func multipleArgs(arg1, arg2 string)(string, string) {
return arg2, arg1
}
Variables
The var
statement declares a list of variables. As in function argument lists, the type of a variable is written after the name of the variable.
Variables that are declared without an initial value are given their zero value. For instance, 0
is for numeric types, false
is for the boolean type and ""
(the empty string) is for strings.
package main
import "fmt"
var var1, var2, var3 bool
func main() {
var num int
fmt.Println(num, var1, var2, var3) //=> 0 false false false
}
As you can see in the code above, A var
statement can be used at package or function level.
Variables with initializers
A var
declaration can include an initializer.
If there is an initializer, the type of the variable can be omitted. The variable will take the type of the initializer.
package main
import "fmt"
func main() {
var str1 = "ruby"
var str2, num1, num2 = "go", 2, 4
fmt.Println(str1,num1, str2, num2) //=>ruby 2 go 4
}
Short variable declarations
You can use :=
to declare a variable inside a function. Go raises an error if you try to declare a variable with :=
outside a function.
package main
import "fmt"
func main() {
str := "Js"
num := 4
boole := true
fmt.Println(str, num, boole) //=> Js 4 true
}
Basic types
Go's basic types are listed in the code below.
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32
// represents a Unicode code point
float32 float64
complex64 complex128
Type conversions
You can not implicitly change the type of a variable in Go. Go raises an error if you try to reassign a value that type is different form the original value type like the code below.
var i int = 100
var f float64 = i //=> // cannot use i (type int) as type float64
If you want to change the type of a variable, you can do so like the code below.
var a uint32 = 1234567890
var b uint8 = uint8(a)
fmt.Println(b) // 210
Constants
Constants are declared with the const
keyword.
Go supports constants of character, string, boolean, and numeric values.
Constants cannot be declared using the :=
syntax.
package main
import "fmt"
const Name = "Go"
func main() {
const Num = 1
const Truth = true
fmt.Println(Name, Num, Truth) //=> Go 1 true
}
Top comments (2)
Great intro so far!
Thank you!