From 3b9f01af448d1fb393d6e10932f3f0176a12bf28 Mon Sep 17 00:00:00 2001 From: asandikci Date: Sun, 9 Jul 2023 21:13:24 +0300 Subject: [PATCH] Initial Commit --- .gitignore | 25 +++++++ README.md | 13 ++++ basics.go | 180 +++++++++++++++++++++++++++++++++++++++++++++++++ development.sh | 7 ++ 4 files changed, 225 insertions(+) create mode 100644 .gitignore create mode 100644 README.md create mode 100644 basics.go create mode 100644 development.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..38fa846 --- /dev/null +++ b/.gitignore @@ -0,0 +1,25 @@ +# ---> Go +# If you prefer the allow list template instead of the deny list, see community template: +# https://github.com/github/gitignore/blob/main/community/Golang/Go.AllowList.gitignore +# +# Binaries for programs and plugins +*.exe +*.exe~ +*.dll +*.so +*.dylib + +# Test binary, built with `go test -c` +*.test + +# Output of the go coverage tool, specifically when used with LiteIDE +*.out + +# Dependency directories (remove the comment below to include it) +# vendor/ + +# Go workspace file +go.work + +# Tutorial examples +examples/ \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..da57b1c --- /dev/null +++ b/README.md @@ -0,0 +1,13 @@ +# Go Learning +Personal Go Learning repo for both step-by-step tutorial througwalk, example programs and personal notes + +## Resources +|Type|Link| +| -- | -- | +|Main Resource|[Go Official Learning](https://go.dev/tour/list)| +|Secondary Resource|[Türkçe Go Eğitimi](https://github.com/Furkan-Gulsen/turkce-go-egitimi)| +|Tertiary Resource|[Tutorialspoint](https://www.tutorialspoint.com/go/index.htm)| +|Example Resources|[Head First Go](https://headfirstgo.com/), [Go by Example](https://gobyexample.com/) | +|Documentation Resources | [Go Official Documentation](https://go.dev/doc/) , [Go Packages Documentation](https://pkg.go.dev/) +|Books|[The Go Programming Language](https://www.gopl.io/) + diff --git a/basics.go b/basics.go new file mode 100644 index 0000000..9794a56 --- /dev/null +++ b/basics.go @@ -0,0 +1,180 @@ +package main + +//SECTION Package Import/Info +import ( // factored import statement, each line one package + "fmt" // Implements basic I/O + "reflect" + + "math/rand" // Implements pseudo-random number generation + //UNSUITABLE for security-sensitive work bcs values are predictable + + "math" // Basic mathematical functions + // Implements run-time reflection) +) + +//!SECTION + +func add(x int, y int) int { return x + y } +func add3(x, y int, z float64) float64 { return float64(x) + float64(y) + z } +func sep(name string) { fmt.Printf("\n\n|-----%s-----|\n", name) } +func msep() { fmt.Printf("\n---\n") } +func swap(x, y string) (string, string) { return y, x } +func naked() (x, z, y int) { // operators couldn't be used here + x = 10 + y = 15 + z = 20 + return // naked return calls named values + // return z, y, x + z // Overrides to named return values BUT still needs 3 elements!!! +} + +var python bool + +// myvar := 10 // ERROR + +func main() { + + //SECTION I/O + fmt.Println("My favorite number is", rand.Intn(10)) + fmt.Printf("Now you have %g problems.\n", math.Sqrt(7)) // C style I/O, printf + // fmt.Println("Now you have %g problems.\n", math.Sqrt(7)) // %g won't work + fmt.Println("Println inserts blanks between operands", "and appends a newline") + fmt.Printf("Type: %T, Value: %v", python, python) + //!SECTION + + sep("Exported Names") + + //SECTION Exported Names + fmt.Printf("if a name begins with a capital letter, it is exported and you can use it with importing package\n") + // fmt.Println(math.pi) WRONG + fmt.Println(math.Pi) // imports pi number + //!SECTION + + sep("Values, Variables and Constants") + + //SECTION Values, Variables and Constants + fmt.Printf("Data types in Go language:\n") + fmt.Printf(` + 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`) + //TODO add explanation for each data types + + msep() + + fmt.Printf("Data types of a variable is static. So you can't modify its type later in code (Like C, unlike python)\n") + var age int // var VARIABLE_NAME DATA_TYPE + age = 32 // = is assigment symbol + // age = "hello" // ERROR + fmt.Println(age) + + fmt.Println("We can also declare multiple variable with same data type at once like: `var VAR1, VAR2 DATA_TYPE`") + var var1, var2, var3 int + + fmt.Println("var statement can be at package or function level") + fmt.Println(var1, var2, var3, python) + + msep() + + fmt.Println("Variables with initializers") + var var4, var5 int = 1, 2 + // var var4, var5 = 1, 2 // ALSO VALID even without datatype + // var var4, var5 = 1 // ERROR + // var var4, var5 = 1, 2, 3 // ERROR + fmt.Println(var4, var5) + + fmt.Println("Different types also can be used together") + var var6, var7, var8 = true, 24.123, "yep" + fmt.Println(var6, var7, var8) + + fmt.Println("Multiple variables can be defined also like this:") + var ( + var9 int = 14 + var10 = 1.34 + ) + fmt.Println(var9, var10) + + fmt.Println("Zero values are 0 for numeric types, false for boolean, and empty string(\"\") for the strings") + msep() + + fmt.Printf("You must assign first values to constants while declaring\n") + const msg1 = "Hello" + fmt.Printf("%s - %s", msg1, reflect.TypeOf(msg1)) // Automatically declaring the type as string + // msg1 = "Goodbye" //ERROR + fmt.Println("Numeric constants are high-precision values.") + + msep() + + fmt.Print("You can also use `:=` for both declaring and assigning a variable\nvariable's type is inferred from the value on the right hand side\n") + // var foo int = 10 // is the same thing with; + foo, foo2 := 10, "hi" + fmt.Println(foo, foo2) + fmt.Println("Not avaliable outside a function (package level)") + + msep() + + fmt.Println("Type conversions: Type(value) can be applied both with:") + + var i int = 42 + var f float64 = float64(i) + var u uint = uint(f) + fmt.Println(reflect.TypeOf(i), reflect.TypeOf(f), reflect.TypeOf(u)) + + // OR + + i2 := 42 + f2 := float64(i2) + u2 := uint(f2) + fmt.Println(reflect.TypeOf(i2), reflect.TypeOf(f2), reflect.TypeOf(u2)) + + fmt.Println("!!!In Go assigments explicit conversions required in different type conversions") + //!SECTION + + sep("Functions") + + //SECTION Functions + fmt.Printf("In Go, type comes after the variable name\nLike `x int`\n") + fmt.Println(add(10, 51)) // Tip: Ctrl+Click in VS Code for see function source quicly + // fmt.Println(add(10)) ERROR + // fmt.Println(add(10, 11, 12)) ERROR + + msep() + + fmt.Printf("Also return types comes after function name and variables\nJust leave a blank for use as void in C\n") + // More info about Go's decleration syntax LINK https://go.dev/blog/declaration-syntax + + msep() + + fmt.Printf("You can also shorten arguments line with just using last arguments type if they are same type\nLike `x, y int`\n") + fmt.Println(add3(10, 11, 12.0141)) + fmt.Println(add3(10, 11, 12.01412352345)) // not precise + fmt.Println(add3(10, 11, 12)) // SUCCESS + //fmt.Println(add3(10.34, 11.53, 12.23)) // ERROR + + msep() + + fmt.Printf("A function can return multiple results\n") + a, b := swap("hello", "world") + fmt.Printf("%s %s\n", a, b) + + msep() + + fmt.Printf("Return values in functions may be named. a `return` statement returns the named values if arguments didn't supplied. This is known as a naked return\n") + fmt.Println("Naked return statements should be used only in short functions!!! Otherwise they can harm readability!!!") + fmt.Println("Note: You can't use `:=` anymore bcs you declared your variables in top of your function") + fmt.Println(naked()) + //!SECTION + + // sep() +} diff --git a/development.sh b/development.sh new file mode 100644 index 0000000..b3d478a --- /dev/null +++ b/development.sh @@ -0,0 +1,7 @@ +#!/bin/bash + +// run go program in cli +go run program.go + +// compile go program +go build program.go