├── README.md └── go-language-for-beginners-tutorial-in-16-parts ├── README.md ├── part-1 ├── 1-go-hello.go ├── 2-calling-functions.go ├── 3-hello-math.go ├── 4-printing-emoji-in-go.go ├── 5-type-of-values.go └── 6-types-in-go.go ├── part-10 ├── 1-map.go ├── 2-map-keys.go ├── 3-length-of-map.go ├── 4-delete-values-map.go ├── 5-iterating-over-map.go ├── 6-iteraging-over-map-values.go ├── 7-iteraging-over-map-keys.go └── 8-initializing-map-with-values.go ├── part-11 ├── 1-language-as-string.go ├── 2-custom-type.go ├── 3-more-custom-types.go ├── 4-custom-type-string-operation.go ├── 5-custom-type-functions.go ├── 6-comparison-custom-type.go └── 7-comparison-different-custom-types.go ├── part-12 ├── 1-struct.go ├── 2-struct-print-field.go ├── 3-struct-directly.go ├── 4-struct-directly-values.go └── 5-struct-composition.go ├── part-13 ├── 1-method.go └── 2-method-custom-type.go ├── part-14 ├── 1-parser-xml-json-csv.go └── 2-parser-interface.go ├── part-15 ├── 1-long-function-running.go └── 2-concurrency-goroutine.go ├── part-16 ├── 1-calculation.go ├── 2-goroutine.go └── 3-channel.go ├── part-2 ├── 1-type-variable.go ├── 2-multiple-variables.go ├── 3-multiple-variables-initializing.go ├── 4-inferring-type-in-variables.go ├── 5-shorthand-variable-declaration.go ├── 6-shorthand-multiple-variables.go ├── 7-assigning-different-type.go └── 8-casting-types-in-go.go ├── part-3 ├── 1-declaring-functions.go ├── 2-functions-with-arguments.go ├── 3-returning-values-functions.go ├── 4-implicit-return-value.go ├── 5-returning-multiple-values.go └── 6-variadic-functions.go ├── part-4 ├── 1-square-number.go ├── 2-square-error-handling.go └── 3-ignoring-error.go ├── part-5 ├── 1-for-loop.go ├── 2-variable-scope.go ├── 3-variable-outside-loop.go ├── 4-infinitive-loop-break.go ├── 5-infinitive-loop-condition.go └── 6-continue-for-loop.go ├── part-6 ├── 1-if-statement.go ├── 2-and-or-if-statement.go ├── 3-if-else-statement.go ├── 4-else-if-statement.go └── 5-else-default-message.go ├── part-7 ├── 1-basic-switch-statement.go ├── 2-switch-break.go ├── 3-switch-multiple-expressions.go └── 4-switch-conditional-range.go ├── part-8 ├── 1-array.go ├── 2-array-position.go ├── 3-array-size.go └── 4-declare-and-initialize-array.go └── part-9 ├── 1-slice.go ├── 2-slice-size.go ├── 3-item-in-slice-dinamically.go ├── 4-append-item-in-slice-one-line.go ├── 5-copying-slices.go ├── 6-slice-items.go └── 7-declaring-and-initializing-slice.go /README.md: -------------------------------------------------------------------------------- 1 | # Golang Guide and Tutorials 2 | 3 | I hope it could be useful to you :) 4 | 5 | Let's keep in touch : ) 6 | 7 | - [Twitter](https://twitter.com/_alex_gama) 8 | - [GitHub](https://github.com/alexandregama) 9 | - [Linkedin](https://www.linkedin.com/in/alexandregama/) 10 | - [Instagram](https://www.instagram.com/_alex_gama) 11 | - [Youtube](https://www.youtube.com/channel/UCn09BXJXOCPLARsqNvxEFuw) 12 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/README.md: -------------------------------------------------------------------------------- 1 | # Go Language for Beginners in 16 Parts 2 | 3 | Hello! 4 | 5 | All the code is from the Go Series: [Go Language for Beginners in 16 Parts](https://blog.hackingcode.io/go-language-for-beginners-tutorial-in-16-parts)! 6 | 7 | - 1 - [Golang characteristics and Go Syntax](https://blog.hackingcode.io/go-language-tutorial-go-characteristics-and-go-syntax-tutorial) 8 | - 2 - [Declaring Variables in Go](https://blog.hackingcode.io/go-language-tutorial-declaring-variables-in-go) 9 | - 3 - [Functions in Go](https://blog.hackingcode.io/go-language-tutorial-go-functions) 10 | - 4 - [Error Handling in Go](https://blog.hackingcode.io/go-language-tutorial-go-error-handling-in-go) 11 | - 5 - [Flow control in Go](https://blog.hackingcode.io/go-language-tutorial-flow-control-in-go) 12 | - 6 - [If..else Statement in Go](https://blog.hackingcode.io/go-language-tutorial-if-else-statement-in-go) 13 | - 7 - [Switch Statement in Go](https://blog.hackingcode.io/go-language-tutorial-switch-statement-in-go) 14 | - 8 - [Data Structures in Go with Array](https://blog.hackingcode.io/go-language-tutorial-data-structure-array-in-go) 15 | - 9 - [Data Structures in Go with Slices](https://blog.hackingcode.io/go-language-tutorial-data-structure-slices-in-go) 16 | - 10 - [Data Structures in Go with Map](https://blog.hackingcode.io/go-language-tutorial-go-data-structure-map-in-go) 17 | - 11 - [Custom Types in Go](https://blog.hackingcode.io/go-language-tutorial-go-custom-types) 18 | - 12 - [Struct in Go](https://blog.hackingcode.io/go-language-tutorial-struct-in-go) 19 | - 13 - [Methods in Go](https://blog.hackingcode.io/go-language-tutorial-methods-in-go) 20 | - 14 - [Interfaces in Go](https://blog.hackingcode.io/go-language-tutorial-interfaces-in-go) 21 | - 15 - [Concurrency with Goroutines in Go](https://blog.hackingcode.io/go-language-tutorial-concurrency-goroutines-in-go) 22 | - 16 - [Concurrency with Goroutines and Channel in Go](https://blog.hackingcode.io/go-language-tutorial-concurrency-goroutine-channel-in-go) 23 | 24 | I hope it could be useful to you :) 25 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-1/1-go-hello.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | importa "fmt" 4 | 5 | func main() { 6 | fmt.Println("Hello, Go World!") 7 | } 8 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-1/2-calling-functions.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("Calling the function: main") 7 | 8 | anotherFunction() 9 | } 10 | 11 | func anotherFunction() { 12 | fmt.Println("Calling the function: anotherFunction()") 13 | } 14 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-1/3-hello-math.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math" 6 | ) 7 | 8 | func main() { 9 | fmt.Println(math.Max(9, 5)) 10 | } 11 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-1/4-printing-emoji-in-go.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "github.com/kyokomi/emoji" 6 | ) 7 | 8 | func main() { 9 | fmt.Println("Hello World Emoji!") 10 | emoji.Println("Do you like :beer: ?") 11 | emoji.Println("Do you like :coffee: ? Of course you like!") 12 | } 13 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-1/5-type-of-values.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "reflect" 6 | ) 7 | 8 | func main() { 9 | fmt.Println(reflect.TypeOf(1)) 10 | fmt.Println(reflect.TypeOf(9.5)) 11 | fmt.Println(reflect.TypeOf("Just a String")) 12 | fmt.Println(reflect.TypeOf(true)) 13 | } 14 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-1/6-types-in-go.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("Hey " + 300) 7 | } 8 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-10/1-map.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := map[string]int{} 7 | languages["java"] = 5 8 | languages["ruby"] = 4 9 | languages["go"] = 2 10 | 11 | fmt.Println(languages) 12 | } 13 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-10/2-map-keys.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := map[string]int{} 7 | languages["java"] = 5 8 | languages["ruby"] = 4 9 | languages["go"] = 2 10 | 11 | fmt.Println("First value:", languages["java"]) 12 | fmt.Println("Second value:", languages["ruby"]) 13 | fmt.Println("Third value:", languages["go"]) 14 | } 15 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-10/3-length-of-map.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := map[string]int{} 7 | languages["java"] = 5 8 | languages["ruby"] = 4 9 | languages["go"] = 2 10 | 11 | fmt.Println("Length of the map:", len(languages)) 12 | } 13 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-10/4-delete-values-map.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := map[string]int{} 7 | languages["java"] = 5 8 | languages["ruby"] = 4 9 | languages["go"] = 2 10 | 11 | delete(languages, "ruby") 12 | delete(languages, "java") 13 | 14 | fmt.Println(languages) 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-10/5-iterating-over-map.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := map[string]int{} 7 | languages["java"] = 5 8 | languages["ruby"] = 4 9 | languages["go"] = 2 10 | 11 | for language, number := range languages { 12 | fmt.Println("Key:", language, "- Value:", number) 13 | } 14 | 15 | for _, number := range languages { 16 | fmt.Println("Value:", number) 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-10/6-iteraging-over-map-values.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := map[string]int{} 7 | languages["java"] = 5 8 | languages["ruby"] = 4 9 | languages["go"] = 2 10 | 11 | for _, number := range languages { 12 | fmt.Println("Value:", number) 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-10/7-iteraging-over-map-keys.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := map[string]int{} 7 | languages["java"] = 5 8 | languages["ruby"] = 4 9 | languages["go"] = 2 10 | 11 | for key, _ := range languages { 12 | fmt.Println("Value:", key) 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-10/8-initializing-map-with-values.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := map[string]int{"java": 4, "ruby": 6, "go": 2} 7 | 8 | fmt.Println(languages) 9 | } 10 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-11/1-language-as-string.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | var language string 6 | 7 | func main() { 8 | language = "Java" 9 | 10 | fmt.Println(language) 11 | } 12 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-11/2-custom-type.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Language string 6 | 7 | func main() { 8 | language := Language("Java") 9 | 10 | fmt.Println(language) 11 | } 12 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-11/3-more-custom-types.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Framework string 6 | type Language string 7 | 8 | func main() { 9 | language := Language("Java") 10 | framework := Framework("Spring 5") 11 | 12 | fmt.Println("Language to learn:", language) 13 | fmt.Println("Framework to learn:", framework) 14 | } 15 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-11/4-custom-type-string-operation.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | type Language string 8 | 9 | func main() { 10 | language := Language("Java") 11 | 12 | fmt.Println(language) 13 | 14 | language = language + " - Ruby" 15 | 16 | fmt.Println(language) 17 | } 18 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-11/5-custom-type-functions.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Language string 6 | 7 | func main() { 8 | language := Language("Java") 9 | 10 | fmt.Println("Language:", language) 11 | 12 | print(string(language)) 13 | } 14 | 15 | func print(value string) { 16 | fmt.Println("Value:", value) 17 | } 18 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-11/6-comparison-custom-type.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Minute int 6 | type Hour int 7 | 8 | func main() { 9 | minutes := Minute(70) 10 | hour := Hour(10) 11 | 12 | if minutes > 60 { 13 | fmt.Println("Minutes is greater than 60") 14 | } 15 | 16 | if hour < 15 { 17 | fmt.Println("Hhours is greater than 15") 18 | } 19 | 20 | } 21 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-11/7-comparison-different-custom-types.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Minute int 6 | type Hour int 7 | 8 | func main() { 9 | minutes := Minute(70) 10 | hour := Hour(10) 11 | 12 | if minutes > hour { 13 | fmt.Println("This will never be executed") 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-12/1-struct.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type VideoCourse struct { 6 | Name string 7 | Language string 8 | TimeMinutes int 9 | } 10 | 11 | func main() { 12 | course := VideoCourse{} 13 | course.Name = "Go Language Overview" 14 | course.Language = "Go" 15 | course.TimeMinutes = 60 16 | 17 | fmt.Println("Video course:", course) 18 | } 19 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-12/2-struct-print-field.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type VideoCourse struct { 6 | Name string 7 | Language string 8 | TimeMinutes int 9 | } 10 | 11 | func main() { 12 | course := VideoCourse{} 13 | course.Name = "Go Language Overview" 14 | course.Language = "Go" 15 | course.TimeMinutes = 60 16 | 17 | fmt.Println("Name:", course.Name) 18 | fmt.Println("Language:", course.Language) 19 | fmt.Println("TimeMinutes:", course.TimeMinutes) 20 | } 21 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-12/3-struct-directly.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type VideoCourse struct { 6 | Name string 7 | Language string 8 | TimeMinutes int 9 | } 10 | 11 | func main() { 12 | course := VideoCourse{Name: "Go Language Overview", Language: "Go", TimeMinutes: 60} 13 | 14 | fmt.Println("Course:", course) 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-12/4-struct-directly-values.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type VideoCourse struct { 6 | Name string 7 | Language string 8 | TimeMinutes int 9 | } 10 | 11 | func main() { 12 | course := VideoCourse{"Go Language Overview", "Go", 60} 13 | 14 | fmt.Println("Course:", course) 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-12/5-struct-composition.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type Minute struct { 6 | Value int 7 | } 8 | 9 | type VideoCourse struct { 10 | Name string 11 | Language string 12 | Time Minute 13 | } 14 | 15 | func main() { 16 | minutes := Minute{Value: 60} 17 | course := VideoCourse{Name: "Go Language Overview", Language: "Go", Time: minutes} 18 | 19 | fmt.Println(course) 20 | } 21 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-13/1-method.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strings" 6 | ) 7 | 8 | type Description string 9 | 10 | func (d Description) Upper() string { 11 | return strings.ToUpper(string(d)) 12 | } 13 | 14 | func main() { 15 | description := Description("My Go special description") 16 | upper := description.Upper() 17 | 18 | fmt.Println(upper) 19 | } 20 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-13/2-method-custom-type.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | type VideoCourse struct { 6 | Minute int 7 | Language string 8 | } 9 | 10 | func (v VideoCourse) Description() string { 11 | return fmt.Sprintf("Video Course for %s with a duration of %d minutes", v.Language, v.Minute) 12 | } 13 | 14 | func main() { 15 | course := VideoCourse{Language: "Go", Minute: 60} 16 | fmt.Println(course) 17 | 18 | description := course.Description() 19 | fmt.Println(description) 20 | } 21 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-14/1-parser-xml-json-csv.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | type XmlParser struct { 8 | Content string 9 | CreatedAt string 10 | } 11 | 12 | func (x XmlParser) Parse() string { 13 | return fmt.Sprintf("Parsing the content in XML: %s", x.Content) 14 | } 15 | 16 | func (x XmlParser) FormatDate() string { 17 | return fmt.Sprintf("Formatting date for XML: %s", x.CreatedAt) 18 | } 19 | 20 | type JsonParser struct { 21 | Content string 22 | CreatedAt string 23 | } 24 | 25 | func (j JsonParser) Parse() string { 26 | return fmt.Sprintf("Parsing the content in JSON: %s", j.Content) 27 | } 28 | 29 | func (j JsonParser) FormatDate() string { 30 | return fmt.Sprintf("Formatting date for JSON: %s", j.CreatedAt) 31 | } 32 | 33 | type CsvParser struct { 34 | Content string 35 | CreatedAt string 36 | } 37 | 38 | func (c CsvParser) Parse() string { 39 | return fmt.Sprintf("Parsing the content in CSV: %s", c.Content) 40 | } 41 | 42 | func (c CsvParser) FormatDate() string { 43 | return fmt.Sprintf("Formatting date for CSV: %s", c.CreatedAt) 44 | } 45 | 46 | func XmlPrinter(xml XmlParser) string { 47 | return xml.Parse() + " - Date - " + xml.FormatDate() 48 | } 49 | 50 | func JsonPrinter(json JsonParser) string { 51 | return json.Parse() + " - Date - " + json.FormatDate() 52 | } 53 | 54 | func CsvPrinter(csv CsvParser) string { 55 | return csv.Parse() + " - Date - " + csv.FormatDate() 56 | } 57 | 58 | func main() { 59 | xmlParser := XmlParser{Content: "My Title<title>", CreatedAt: "2018-01-20"} 60 | xmlPrinter := XmlPrinter(xmlParser) 61 | fmt.Println(xmlPrinter) 62 | 63 | jsonParser := JsonParser{Content: "{'title': 'My Title'}", CreatedAt: "2018-01-25"} 64 | jsonPrinter := JsonPrinter(jsonParser) 65 | fmt.Println(jsonPrinter) 66 | 67 | csvParser := CsvParser{Content: "My Content; Another Conent", CreatedAt: "2018-01-25"} 68 | csvPrinter := CsvPrinter(csvParser) 69 | fmt.Println(csvPrinter) 70 | } 71 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-14/2-parser-interface.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | ) 6 | 7 | type XmlParser struct { 8 | Content string 9 | CreatedAt string 10 | } 11 | 12 | func (x XmlParser) Parse() string { 13 | return fmt.Sprintf("Parsing the content in XML: %s", x.Content) 14 | } 15 | 16 | func (x XmlParser) FormatDate() string { 17 | return fmt.Sprintf("Formatting date for XML: %s", x.CreatedAt) 18 | } 19 | 20 | type JsonParser struct { 21 | Content string 22 | CreatedAt string 23 | } 24 | 25 | func (j JsonParser) Parse() string { 26 | return fmt.Sprintf("Parsing the content in JSON: %s", j.Content) 27 | } 28 | 29 | func (j JsonParser) FormatDate() string { 30 | return fmt.Sprintf("Formatting date for JSON: %s", j.CreatedAt) 31 | } 32 | 33 | type CsvParser struct { 34 | Content string 35 | CreatedAt string 36 | } 37 | 38 | func (c CsvParser) Parse() string { 39 | return fmt.Sprintf("Parsing the content in CSV: %s", c.Content) 40 | } 41 | 42 | func (c CsvParser) FormatDate() string { 43 | return fmt.Sprintf("Formatting date for CSV: %s", c.CreatedAt) 44 | } 45 | 46 | type AvroParser struct { 47 | Content string 48 | CreatedAt string 49 | } 50 | 51 | func (a AvroParser) Parse() string { 52 | return fmt.Sprintf("Parsing the content in Avro: %s", a.Content) 53 | } 54 | 55 | func (a AvroParser) FormatDate() string { 56 | return fmt.Sprintf("Formatting date for Avro: %s", a.CreatedAt) 57 | } 58 | 59 | type Parser interface { 60 | Parse() string 61 | FormatDate() string 62 | } 63 | 64 | func Printer(format Parser) string { 65 | return format.Parse() + " - Date - " + format.FormatDate() 66 | } 67 | 68 | func main() { 69 | xmlParser := XmlParser{Content: "<title>My Title<title>", CreatedAt: "2018-01-20"} 70 | xmlPrinter := Printer(xmlParser) 71 | fmt.Println(xmlPrinter) 72 | 73 | jsonParser := JsonParser{Content: "{'title': 'My Title'}", CreatedAt: "2018-01-25"} 74 | jsonPrinter := Printer(jsonParser) 75 | fmt.Println(jsonPrinter) 76 | 77 | csvParser := CsvParser{Content: "My Content; Another Content", CreatedAt: "2018-01-25"} 78 | csvPrinter := Printer(csvParser) 79 | fmt.Println(csvPrinter) 80 | 81 | avroParser := AvroParser{Content: "My avro content", CreatedAt: "2018-01-25"} 82 | avroParser := Printer(avroParser) 83 | fmt.Println(avroParser) 84 | } 85 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-15/1-long-function-running.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func callWebService(value int) { 9 | fmt.Println("WebService started:", value) 10 | time.Sleep(3 * time.Second) 11 | fmt.Println("WebService finished:", value) 12 | } 13 | 14 | func main() { 15 | callWebService(1) 16 | callWebService(2) 17 | callWebService(3) 18 | } 19 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-15/2-concurrency-goroutine.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func callWebService(value int) { 9 | fmt.Println("WebService started:", value) 10 | time.Sleep(3 * time.Second) 11 | fmt.Println("WebService finished:", value) 12 | } 13 | 14 | func main() { 15 | go callWebService(1) 16 | go callWebService(2) 17 | go callWebService(3) 18 | time.Sleep(10 * time.Second) 19 | } 20 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-16/1-calculation.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func callWebService() int { 9 | fmt.Println("Calling webservice") 10 | time.Sleep(5 * time.Second) 11 | fmt.Println("Webservice Finished") 12 | return 10 13 | } 14 | 15 | func showToUser() { 16 | fmt.Println("Showing info to User..") 17 | } 18 | 19 | func main() { 20 | result := callWebService() 21 | 22 | showToUser() 23 | 24 | fmt.Println("Execution finished with the result:", result) 25 | time.Sleep(8 * time.Second) 26 | } 27 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-16/2-goroutine.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | func callWebService() { 9 | go func() { 10 | fmt.Println("Calling webservice") 11 | time.Sleep(5 * time.Second) 12 | fmt.Println("Webservice Finished") 13 | }() 14 | } 15 | 16 | func showToUser() { 17 | fmt.Println("Showing info to User..") 18 | } 19 | 20 | func main() { 21 | callWebService() 22 | 23 | showToUser() 24 | 25 | fmt.Println("Execution finished with the result:") 26 | time.Sleep(8 * time.Second) 27 | } 28 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-16/3-channel.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "time" 6 | ) 7 | 8 | var webservice = make(chan int) 9 | 10 | func callWebService() { 11 | go func() { 12 | fmt.Println("Calling webservice") 13 | time.Sleep(5 * time.Second) 14 | fmt.Println("Webservice Finished") 15 | webservice <-10 16 | }() 17 | } 18 | 19 | func showToUser() { 20 | fmt.Println("Showing info to User..") 21 | } 22 | 23 | func main() { 24 | callWebService() 25 | 26 | showToUser() 27 | 28 | result := <-webservice 29 | 30 | fmt.Println("Execution finished with the result:", result) 31 | time.Sleep(8 * time.Second) 32 | } 33 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-2/1-type-variable.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var number int 7 | number = 10 8 | 9 | fmt.Println(number) 10 | } 11 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-2/2-multiple-variables.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var number, amount int 7 | number = 10 8 | amount = 15 9 | 10 | fmt.Println(number, amount) 11 | } 12 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-2/3-multiple-variables-initializing.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var number, amount = 10, 15 7 | var sum = 20 8 | 9 | fmt.Println(number, amount, sum) 10 | } 11 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-2/4-inferring-type-in-variables.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var number, amount = 10, 15 7 | var sum = 20 8 | 9 | fmt.Println(number, amount, sum) 10 | } 11 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-2/5-shorthand-variable-declaration.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | amount := 15 8 | 9 | fmt.Println(number, amount) 10 | } 11 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-2/6-shorthand-multiple-variables.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number, amount := 10, 15 7 | 8 | fmt.Println(number, amount) 9 | } 10 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-2/7-assigning-different-type.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var number int = 10 7 | var price float64 = 15.10 8 | 9 | fmt.Println(number, price) 10 | 11 | price = number 12 | fmt.Println(pricd) 13 | } 14 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-2/8-casting-types-in-go.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var price float64 = 15 7 | 8 | fmt.Println("Price before:", price) 9 | 10 | var number int = 10 11 | 12 | price = float64(number) 13 | 14 | fmt.Println("Price after: ", price) 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-3/1-declaring-functions.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | fmt.Println("Executing inside the main() function") 7 | 8 | anotherFunction() 9 | } 10 | 11 | func anotherFunction() { 12 | fmt.Println("Executing inside the anotherFuntion()") 13 | } 14 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-3/2-functions-with-arguments.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | sumAndPrint(3, 6) 7 | } 8 | 9 | func sumAndPrint(first int, second int) { 10 | sum := first + second 11 | 12 | fmt.Println(sum) 13 | } 14 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-3/3-returning-values-functions.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | value := sum(9, 7) 7 | 8 | fmt.Println("Total value:", value) 9 | } 10 | 11 | func sum(first, second int) int { 12 | totalValue := first + second 13 | 14 | return totalValue 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-3/4-implicit-return-value.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | total := sum(8, 12) 7 | 8 | fmt.Println("Total value:", total) 9 | } 10 | 11 | func sum(first, second int) (amount int) { 12 | amount = first + second 13 | 14 | return 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-3/5-returning-multiple-values.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | first, second, third := primeNumbers() 7 | 8 | fmt.Println("Prime numbers:", first, second, third) 9 | } 10 | 11 | func primeNumbers() (int, int, int) { 12 | return 1, 3, 5 13 | } 14 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-3/6-variadic-functions.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | printNumbers() 7 | } 8 | 9 | func printNumbers(numbers ...int) { 10 | fmt.Println(numbers) 11 | } 12 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-4/1-square-number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math" 6 | ) 7 | 8 | func main() { 9 | result := square(16) 10 | 11 | fmt.Println("Square of 16 is", result) 12 | } 13 | 14 | func square(value float64) float64 { 15 | return math.Sqrt(value) 16 | } 17 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-4/2-square-error-handling.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math" 6 | "log" 7 | ) 8 | 9 | func main() { 10 | result, err := square(-1) 11 | if err != nil { 12 | log.Fatal(err) 13 | } 14 | 15 | fmt.Println("Square of 16 is", result) 16 | } 17 | 18 | func square(value float64) (float64, error) { 19 | if value < 0 { 20 | return 0, fmt.Errorf("You can not use negative numbers!") 21 | } 22 | return math.Sqrt(value), nil 23 | } 24 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-4/3-ignoring-error.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "math" 6 | ) 7 | 8 | func main() { 9 | result, _ := square(-1) 10 | 11 | fmt.Println("Square of 16 is", result) 12 | } 13 | 14 | func square(value float64) (float64, error) { 15 | if value < 0 { 16 | return 0, fmt.Errorf("You can not use negative numbers!") 17 | } 18 | return math.Sqrt(value), nil 19 | } 20 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-5/1-for-loop.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | for i := 0; i < 5; i++ { 7 | fmt.Println("Value:", i) 8 | } 9 | } 10 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-5/2-variable-scope.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | numberOutside := 10 7 | for i := 0; i < 5; i++ { 8 | numberInside := 5 9 | numberOutside++ 10 | } 11 | fmt.Println("Number outside loop:", numberOutside) 12 | fmt.Println("Number inside loop:", numberInside) 13 | } 14 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-5/3-variable-outside-loop.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | i := 0 7 | for i < 5 { 8 | fmt.Println("Value:", i) 9 | i++ 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-5/4-infinitive-loop-break.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | for { 7 | fmt.Println("Will break after this line!") 8 | break 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-5/5-infinitive-loop-condition.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | for { 7 | importantValue := importantFunction() 8 | if importantValue == 10 { 9 | fmt.Println(importantValue) 10 | break 11 | } 12 | } 13 | } 14 | 15 | func importantFunction() int { 16 | return 10 17 | } 18 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-5/6-continue-for-loop.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | for i := 0; i <= 10; i++ { 7 | if i%2 == 0 { 8 | continue 9 | } 10 | fmt.Println(i) 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-6/1-if-statement.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | if number >= 5 { 8 | fmt.Println("I will print the value:", number) 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-6/2-and-or-if-statement.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | amount := 15 8 | 9 | if number >= 5 && amount <= 20 { 10 | fmt.Println("This will be printed!") 11 | } 12 | 13 | if number >= 15 || amount <= 20 { 14 | fmt.Println("This will be printed!") 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-6/3-if-else-statement.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | if number < 5 { 8 | fmt.Println("Will not execute this") 9 | } else { 10 | fmt.Println("The code in the else will be executed!") 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-6/4-else-if-statement.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | if number < 5 { 8 | fmt.Println("Will not be printed!") 9 | } else if number < 8 { 10 | fmt.Println("Will not be printed!") 11 | } else if number < 12 { 12 | fmt.Println("Will be printed, since number is less than 12!") 13 | } else if number < 15 { 14 | fmt.Println("Will no be printed, since the last statement was printed out!") 15 | } else { 16 | fmt.Println("Default") 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-6/5-else-default-message.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | if number > 5 { 8 | fmt.Println("Will not be printed!") 9 | } else if number < 7 { 10 | fmt.Println("Will not be printed!") 11 | } else if number < 9 { 12 | fmt.Println("Will not be printed!") 13 | } else { 14 | fmt.Println("Message Default!") 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-7/1-basic-switch-statement.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | switch number { 8 | case 5: 9 | fmt.Println("The number is 5") 10 | case 7: 11 | fmt.Println("The number is 7") 12 | case 10: 13 | fmt.Println("The number is 10") 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-7/2-switch-break.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | switch number { 8 | case 5: 9 | fmt.Println("The number is 5") 10 | case 10: 11 | fmt.Println("The number is 10") 12 | case 15: 13 | fmt.Println("This will not be checked!") 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-7/3-switch-multiple-expressions.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | switch number { 8 | case 3, 8, 15: 9 | fmt.Println("The number is in the first range!") 10 | case 9, 10, 20: 11 | fmt.Println("The number is in the second range!") 12 | case 16, 21, 25: 13 | fmt.Println("The number is in the third range!") 14 | } 15 | 16 | } 17 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-7/4-switch-conditional-range.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | number := 10 7 | switch { 8 | case number > 2 && number <= 8: 9 | fmt.Println("The number belongs to the first conditional") 10 | case number > 5 && number <= 10: 11 | fmt.Println("The number belongs to the second conditional") 12 | case number > 15 && number <= 20: 13 | fmt.Println("The number belongs to the third conditional") 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-8/1-array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var languages [5]string 7 | languages[0] = "Go" 8 | languages[1] = "Ruby" 9 | languages[2] = "Pony" 10 | languages[3] = "Erlang" 11 | languages[4] = "Java" 12 | 13 | fmt.Println(languages) 14 | } 15 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-8/2-array-position.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var languages [5]string 7 | languages[0] = "Go" 8 | languages[1] = "Ruby" 9 | languages[2] = "Pony" 10 | languages[3] = "Erlang" 11 | languages[4] = "Java" 12 | 13 | fmt.Println(languages[3]) 14 | } 15 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-8/3-array-size.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | var languages [5]string 7 | languages[0] = "Go" 8 | languages[1] = "Ruby" 9 | languages[2] = "Pony" 10 | languages[3] = "Erlang" 11 | languages[4] = "Java" 12 | 13 | fmt.Println("Array size:", len(languages)) 14 | } 15 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-8/4-declare-and-initialize-array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := [5]string{"Go", "Ruby", "Pony", "Erlang", "Java"} 7 | 8 | fmt.Println(languages) 9 | } 10 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-9/1-slice.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := make([]string, 3) 7 | languages[0] = "Go" 8 | languages[1] = "Ruby" 9 | languages[2] = "Pony" 10 | 11 | fmt.Println(languages) 12 | } 13 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-9/2-slice-size.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := make([]string, 3) 7 | languages[0] = "Go" 8 | languages[1] = "Ruby" 9 | languages[2] = "Pony" 10 | 11 | fmt.Println("Slice size:", len(languages)) 12 | } 13 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-9/3-item-in-slice-dinamically.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := make([]string, 3) 7 | languages[0] = "Go" 8 | languages[1] = "Ruby" 9 | languages[2] = "Pony" 10 | 11 | fmt.Println("Slice size:", len(languages)) 12 | 13 | languages = append(languages, "Erlang") 14 | languages = append(languages, "Java") 15 | 16 | fmt.Println("New slice size:", len(languages)) 17 | } 18 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-9/4-append-item-in-slice-one-line.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := make([]string, 3) 7 | languages[0] = "Go" 8 | languages[1] = "Ruby" 9 | languages[2] = "Pony" 10 | 11 | fmt.Println("Slice size:", len(languages)) 12 | 13 | languages = append(languages, "Erlang", "Java", "JavaScript", "Python") 14 | 15 | fmt.Println("New slice size:", len(languages)) 16 | } 17 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-9/5-copying-slices.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := make([]string, 3) 7 | languages[0] = "Go" 8 | languages[1] = "Ruby" 9 | languages[2] = "Pony" 10 | 11 | learn := make([]string, len(languages)) 12 | copy(learn, languages) 13 | 14 | fmt.Println(learn) 15 | } 16 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-9/6-slice-items.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := make([]string, 5) 7 | languages[0] = "Ruby" 8 | languages[1] = "JavaScript" 9 | languages[2] = "Java" 10 | languages[3] = "Scala" 11 | languages[4] = "Go" 12 | 13 | dynamicLanguages := languages[0:2] 14 | fmt.Println(dynamicLanguages) 15 | 16 | staticTyped := languages[2:5] 17 | fmt.Println(staticTyped) 18 | } 19 | -------------------------------------------------------------------------------- /go-language-for-beginners-tutorial-in-16-parts/part-9/7-declaring-and-initializing-slice.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | languages := []string{"Ruby", "Java", "Pony", "Go", "Erlang"} 7 | } 8 | --------------------------------------------------------------------------------