GoLang Fundamentals

• Organize the code just like we organize our files into computers
• Folder name should be same as the package name
• One package many files (If something is in lowercase, it will not be exported outside the package)
• Package scope: something in one file is accessible to another file
• Imports have file scope
• Capitalization:
  Uppercase: exported, visible outside the package
  Lower case: unexported, not visible outside the package

name.go
package stringutil
/*My name will be exported because
 it starts with capital letter*/
var MyName = "Software"
var yourname = "Product"

reverseTwo.go
package stringutil
func reverseTwo(s string) string {
 r := []rune(s)
 for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
 r[i], r[j] = r[j], r[i]
 }
 return string(r)
}

reverse.go
package stringutil
//Reverse returns its argument as reversed string
func Reverse(s string) string {
 return reverseTwo(s)
}

main.go
package main
import (
 "fmt"
 "package/stringutil"
)
func main() {
 fmt.Println(stringutil.Reverse(stringutil.MyName))
 //fmt.Println(stringutil.Reverse(stringutil.yourname))
}

• Boolean Types – These are predefined constants : (a)true (b) false
• Numeric Types – Represents (a) integer types  (b) Floating point values
• String type – Predeclared string type is string having set of characters
• Derived types – (a)Pointer types (b)Array types (c) Structure types (d)Union types (e)Function types (f) Slice types (g)interface types  (h) Map types

main.go
package main
import (
 "fmt"
)
//Default Values of Variables (Package Scope)
var h int
var i string
var j float64
var k bool
func main() {
 //Shorthand Notations
 a := 34
 b := "Learning Golang"
 c := 5.23
 d := true
 e := "Welcome"
 f := `How are you?`
 g := 'S'
 //Variable declaration
 var info string
 info = "Welcome to Golang"
 //Declare many at once
 var l, m, n string //same type
 l = "Google"
 //Initialize many at once
 var o, p int = 32, 54
 //Mixed Types
 var q, r, s = true, 433, "Hello"
 t, u, v := false, 54.56, 'H'
 w := `Hello` //Backtricks considered as string

 fmt.Printf("Type:%T \t Value:%v \n", a, a)
 fmt.Printf("Type:%T \t Value:%v \n", b, b)
 fmt.Printf("Type:%T \t Value:%v \n", c, c)
 fmt.Printf("Type:%T \t Value:%v \n", d, d)
 fmt.Printf("Type:%T \t Value:%v \n", e, e)
 fmt.Printf("Type:%T \t Value:%v \n", f, f)
 fmt.Printf("Type:%T \t Value:%v \n", g, g)
 fmt.Println()
 fmt.Println("Default Values---")
 fmt.Println("int:", h)
 fmt.Println("string:", i) //string has empty value
 fmt.Println("float64:", j)
 fmt.Println("bool:", k)
 fmt.Println()
 fmt.Println(info)
 fmt.Println("l,m,n:", l, m, n)
 fmt.Println("o,p:", o, p)
 fmt.Println("q,r,s:", q, r, s)
 fmt.Println("t,u,v:", t, u, v)
 fmt.Println("backtricks w:", w)
}

name.go
package myPack 
var MyName = "Anthony"

your.go
package myPack
var YourName = "Gonsalves"

main.go
package main
import (
 "scope/scopes/myPack" "fmt"
)
var x string = "Welcome to Golang" //Accessed in whole program
func main() {
 y := print(x) //y cannot be accessed outside this function
 fmt.Println(y)
 z := myPack.MyName /*MyName should start with Capital letter
 because we are accessing it from another package*/
 fmt.Println(z)
 a := myPack.YourName
 fmt.Println(a)
 b:=0
 start:=call() //Assigning a func expression to value
 fmt.Println(start)
}
func print(s string) string {
 return s
}
func call() int {
x:=11
x++
return x
}

main.go
package main
import (
 "fmt"
)
func main() {
 a := "Software Development"
 b := "Production Planning"
 fmt.Println(a)
 //b is declared but not used so it's invalid code
}

main.go
package main
import (
“fmt”
“io/ioutil”
“net/http”
)
func main() {
res, _ := http.Get(“https://www.google.com/”)
/*Actually here,http.Get() returns resp and error but Here it is saying that I don’t want to use the error variable by specifying ‘_’ */
page, _ := ioutil.ReadAll(res.Body)
res.Body.Close()
fmt.Printf(“%s”, page)
}

main.go
package main
import (
 "fmt"
)
type Byte float64
//Single Value Initialization
const pi = 3.14

//Multi Value Initialization
const (
 userName = "product"
 password = "product@123" //String constant
 a = iota //2
 b = iota //3
 c = 1 << iota //16 (iota=4)
 d float64 = iota * 5 //25 iota val inc by 1
)
func main() {
 func() {
 rad := pi * 7 * 7
 fmt.Println("Radius of Circle:", rad)
 fmt.Println("UserName:", userName)
 fmt.Println("Password", password)
 fmt.Println(a)
 fmt.Println(b)
 fmt.Println(c)
 fmt.Println(d)
 }()
}

main.go
package main
import (
 "fmt"
)
const pi = 3.14
var message string = "Product"
func main() {
 responseCode := 101
 fmt.Printf("\n message:%v,Address:%v", message, &message)
 fmt.Printf("\n responseCode:%v,Address:%v", responseCode, &responseCode)
 area := pi * 7 * 7
 fmt.Printf("\n Area:%v,Address:%v", area, &area)
}

package main
import (
 "fmt"
)
func main() {
 a := 50
 fmt.Println(a)
 fmt.Println("a:", &a) //Address of a
 /*Here x will point to the address where a
 is stored */
 var x = &a //Referencing
 /*Here x will get the value by using '*' */
 fmt.Println("x:", *x) //DeReferencing
}

package main 
import ( 
 "fmt" 
) )
func main() { \
s := 5 
call(s) 
fmt.Println(s) 
} 
func call(n int) { 
 n++ 
} 
//Here o/p is still 5

package main
import ( 
"fmt"
)
func main() {
s := 5
call(&s)
fmt.Println(s) 
}
func call(n *int) {
*n++
}
//Here o/p is will 6 as required

package main
import (
 "fmt"
)
func main() {
 for i := 1; i < 100; i++ {
 if i%2 == 1 {
 fmt.Println(i, "is Odd number")
 } else {
 fmt.Println(i, "is Even number")
 }
 }
}