├── 1-hello-world └── main.go ├── 13-tests ├── main.go └── main_test.go ├── 3-constants └── main.go ├── 6-arrays └── main.go ├── 4-funcoes └── main.go ├── 5-structs └── main.go ├── 8-maps └── main.go ├── 14-goroutines └── main.go ├── 7-slices └── main.go ├── 16-mutexes ├── main-sync-map.go └── main.go ├── 12-errors └── main.go ├── 10-interfaces └── main.go ├── 15-channel └── main.go ├── 17-waitgroup └── main.go ├── 11-errors └── main.go ├── 2-variables └── main.go ├── 9-methods └── main.go └── LICENSE /1-hello-world/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("Olá nobre guerreiros!") 7 | } 8 | -------------------------------------------------------------------------------- /13-tests/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type Calculator struct{} 4 | 5 | func (*Calculator) Add(x, y int) int { 6 | return x + y 7 | } 8 | -------------------------------------------------------------------------------- /3-constants/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | const PI = 3.14 6 | 7 | func main() { 8 | fmt.Println("O valor de PI é", PI) 9 | } 10 | -------------------------------------------------------------------------------- /6-arrays/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var mandamentos [2]string 7 | mandamentos[0] = "Amor" 8 | mandamentos[1] = "Paz" 9 | fmt.Println("Mandamentos: ", mandamentos) 10 | } 11 | -------------------------------------------------------------------------------- /4-funcoes/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | // exemplo de função privada 6 | func add(x int, y int) int { 7 | return x + y 8 | } 9 | 10 | func main() { 11 | fmt.Println("O resultado de 10 + 20 é", add(10, 20)) 12 | } 13 | -------------------------------------------------------------------------------- /5-structs/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Person struct { 6 | Name string 7 | Age int 8 | Active bool 9 | } 10 | 11 | func main() { 12 | p := Person{ 13 | Name: "Wilson Júnior", 14 | Age: 24, 15 | Active: true, 16 | } 17 | fmt.Println("Nome", p.Name) 18 | fmt.Println("Age", p.Age) 19 | fmt.Println("Active", p.Active) 20 | } 21 | -------------------------------------------------------------------------------- /8-maps/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | people := map[string]int{ 7 | "wilson": 25, 8 | "andre": 26, 9 | } 10 | 11 | people["junior"] = 10 12 | 13 | for name, age := range people { 14 | fmt.Printf("Chave %s do mapa valor: %d\n", name, age) 15 | } 16 | 17 | delete(people, "wilson") 18 | fmt.Printf("Posição não alocada: %d\n", people["wilson"]) 19 | } 20 | -------------------------------------------------------------------------------- /14-goroutines/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func task(name string) { 9 | for { 10 | fmt.Println("Executing task", name) 11 | time.Sleep(time.Second) 12 | } 13 | } 14 | 15 | func main() { 16 | go task("goroutine 1") 17 | go task("goroutine 2") 18 | go task("goroutine 3") 19 | go task("goroutine 4") 20 | go task("goroutine 5") 21 | 22 | task("main") 23 | } 24 | -------------------------------------------------------------------------------- /13-tests/main_test.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "testing" 5 | ) 6 | 7 | func TestAddSuccess(t *testing.T) { 8 | calculator := &Calculator{} 9 | result := calculator.Add(42, 10) 10 | if result != 52 { 11 | t.Error("Result of 42 + 10 must be 52") 12 | } 13 | } 14 | 15 | func TestAddFail(t *testing.T) { 16 | calculator := &Calculator{} 17 | result := calculator.Add(42, 10) 18 | if result != 50 { 19 | t.Error("Result of 42 + 10 must be 52") 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /7-slices/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | linguagens := []string{"python", "ruby", "javascript"} 7 | linguagens = append(linguagens, "go") 8 | 9 | fmt.Println("Linguagens da globo.com: ", linguagens) 10 | fmt.Println("Linguagens da globo.com: ", linguagens[1:3]) 11 | 12 | for i, linguagem := range linguagens { 13 | fmt.Printf( 14 | "Linguagem na posição %d do slice, valor: %s\n", 15 | i, 16 | linguagem, 17 | ) 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /16-mutexes/main-sync-map.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strconv" 6 | "sync" 7 | "time" 8 | ) 9 | 10 | var globalMap = &sync.Map{} 11 | 12 | func worker(id int) { 13 | key := fmt.Sprintf("blah-%d", id) 14 | 15 | globalMap.Store(key, strconv.Itoa(id*id)) 16 | value, found := globalMap.Load(key) 17 | 18 | fmt.Println(key, value, found) 19 | } 20 | 21 | func main() { 22 | for i := 0; i < 100; i++ { 23 | go worker(i) 24 | } 25 | time.Sleep(time.Second) 26 | } 27 | -------------------------------------------------------------------------------- /16-mutexes/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strconv" 6 | ) 7 | 8 | type SafeMap struct { 9 | m map[string]string 10 | } 11 | 12 | func (s *SafeMap) Set(key, value string) { 13 | s.m[key] = value 14 | } 15 | 16 | func (s *SafeMap) Get(key string) string { 17 | return s.m[key] 18 | } 19 | 20 | func main() { 21 | s := &SafeMap{ 22 | m: map[string]string{}, 23 | } 24 | 25 | for i := 0; i < 100; i++ { 26 | go s.Set("blah", strconv.Itoa(i)) 27 | go fmt.Println(s.Get("blah")) 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /12-errors/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type MyError struct { 6 | Code int 7 | Cause string 8 | } 9 | 10 | func (e *MyError) Error() string { 11 | return fmt.Sprintf("Error %d", e.Code) 12 | } 13 | 14 | func doSomething() error { 15 | return &MyError{ 16 | Code: 100, 17 | Cause: "Unexpected ...", 18 | } 19 | } 20 | 21 | func main() { 22 | err := doSomething() 23 | 24 | myError, ok := err.(*MyError) 25 | if ok { 26 | fmt.Println("Code of error:", myError.Code) 27 | fmt.Println("Cause of error:", myError.Cause) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /10-interfaces/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Animal interface { 6 | Shout() string 7 | } 8 | 9 | type Cow struct{} 10 | 11 | func (c *Cow) Shout() string { 12 | return "Muuu" 13 | } 14 | 15 | type Dog struct{} 16 | 17 | func (d *Dog) Shout() string { 18 | return "Rau rau!" 19 | } 20 | 21 | func main() { 22 | var animal Animal 23 | 24 | animal = &Cow{} 25 | callMyAnimal(animal) 26 | 27 | animal = &Dog{} 28 | callMyAnimal(animal) 29 | } 30 | 31 | func callMyAnimal(a Animal) { 32 | fmt.Println("My animal says:", a.Shout()) 33 | } 34 | -------------------------------------------------------------------------------- /15-channel/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func task(name string, channel chan int) { 9 | for { 10 | value := <-channel 11 | fmt.Println("Executing task", value, "by", name) 12 | } 13 | } 14 | 15 | func main() { 16 | channel := make(chan int) 17 | 18 | go task("goroutine 1", channel) 19 | go task("goroutine 2", channel) 20 | go task("goroutine 3", channel) 21 | go task("goroutine 4", channel) 22 | go task("goroutine 5", channel) 23 | 24 | for i := 0; i < 100; i++ { 25 | channel <- i 26 | } 27 | // wait all gorotines to finish 28 | time.Sleep(time.Second) 29 | } 30 | -------------------------------------------------------------------------------- /17-waitgroup/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "sync" 6 | "time" 7 | ) 8 | 9 | type MultiWorker struct { 10 | wg sync.WaitGroup 11 | } 12 | 13 | func (w *MultiWorker) Run() { 14 | for i := 0; i < 100; i++ { 15 | w.wg.Add(1) 16 | go w.runJob(i) 17 | } 18 | w.wg.Wait() 19 | fmt.Println("All jobs have finished successfully") 20 | } 21 | 22 | func (w *MultiWorker) runJob(id int) { 23 | defer w.wg.Done() 24 | defer fmt.Printf("Job %d finished\n", id) 25 | 26 | if (id % 2) == 0 { 27 | time.Sleep(time.Second) 28 | } else { 29 | time.Sleep(2 * time.Second) 30 | } 31 | } 32 | 33 | func main() { 34 | w := &MultiWorker{} 35 | w.Run() 36 | } 37 | -------------------------------------------------------------------------------- /11-errors/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "errors" 5 | "fmt" 6 | ) 7 | 8 | // ErrNotAllowed é chamado quando o menor tem menos de 19 anos 9 | var ErrNotAllowed = errors.New("Não permitida a entrada") 10 | 11 | func entryInParty(age int) (string, error) { 12 | if age < 18 { 13 | return "", ErrNotAllowed 14 | } 15 | 16 | return "TICKET", nil 17 | } 18 | 19 | func main() { 20 | ticket, err := entryInParty(17) 21 | 22 | if err != nil { 23 | fmt.Println("Falha ao entrar na Balada: ", err) 24 | } 25 | 26 | ticket, err = entryInParty(17) 27 | 28 | if err == ErrNotAllowed { 29 | fmt.Println("Chame os pais da criança!") 30 | } 31 | 32 | fmt.Println("Ticket liberado", ticket) 33 | } 34 | -------------------------------------------------------------------------------- /2-variables/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | // int 7 | // declarando uma variável utilizando o modelo pré declarativo 8 | var x int // ou var x int = 10 9 | x = 10 10 | fmt.Printf("O valor de 'x' é %d\n", x) 11 | 12 | // declarando uma variável utilizando o modelo auto-declarativo 13 | a := 20 14 | fmt.Printf("O valor de 'a' era %d\n", a) 15 | a = 30 16 | fmt.Printf("O valor de 'a' agora é %d\n", a) 17 | 18 | // string 19 | name := "wilson" 20 | fmt.Println("Meu nome é", name) 21 | 22 | // float64 23 | pi := 3.14 24 | fmt.Printf("O valor de PI é %0.6f\n", pi) 25 | 26 | // bool 27 | verdade := true 28 | mentira := false 29 | 30 | fmt.Println("Verdade é igual a mentira:", verdade == mentira) 31 | } 32 | -------------------------------------------------------------------------------- /9-methods/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Person struct { 6 | Name string 7 | Age int 8 | } 9 | 10 | func (p *Person) String() string { 11 | if p.Age < 18 { 12 | return fmt.Sprintf("Olá jovem %s, seja bem vindo", p.Name) 13 | } else if p.Age > 50 { 14 | return fmt.Sprintf("Olá senhor %s, seja bem vindo", p.Name) 15 | } 16 | 17 | return fmt.Sprintf("Olá %s, seja bem vindo", p.Name) 18 | } 19 | 20 | func (p *Person) privateMethod() int { 21 | return p.Age * 4 22 | } 23 | 24 | func main() { 25 | person := Person{Name: "júnior", Age: 17} 26 | fmt.Println(person.String()) 27 | 28 | person = Person{Name: "Wilson", Age: 27} 29 | fmt.Println(person.String()) 30 | 31 | person = Person{Name: "Antônio", Age: 60} 32 | fmt.Println(person.String()) 33 | 34 | } 35 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Wilson Júnior 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | --------------------------------------------------------------------------------