├── .gitignore
├── 001_hello_golang
    └── main.go
├── 002_package
    ├── nested
    │   ├── hello
    │   │   ├── hello.go
    │   │   └── test.go
    │   ├── nested.go
    │   └── say
    │   │   └── say.go
    └── simple
    │   └── simple.go
├── 003_variables
    └── variables.go
├── 004_variables_scope
    ├── closureScope
    │   └── main.go
    ├── fileScope
    │   └── main.go
    └── packageScope
    │   ├── main.go
    │   └── nestedPackage
    │       └── airplane.go
├── 005_constans
    └── constans.go
├── 006_control_flow
    ├── for
    │   └── main.go
    ├── if
    │   └── main.go
    └── switch
    │   └── main.go
├── 007_array
    └── main.go
├── 008_slices
    ├── difference.go
    └── slice.go
├── 009_map
    ├── difference.go
    └── map.go
├── 010_func
    └── main.go
├── 011_closure
    └── main.go
├── 012_params
    └── main.go
├── 013_callback
    └── main.go
├── 014_defer
    └── main.go
├── 015_struct
    └── main.go
├── 016_methods
    └── main.go
└── 017_interfaces
    └── main.go


/.gitignore:
--------------------------------------------------------------------------------
1 | vendor/**
2 | debug*
3 | .idea
4 | .vscode


--------------------------------------------------------------------------------
/001_hello_golang/main.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | import "fmt"
4 | 
5 | func main() {
6 | 	fmt.Println("Hello golang!")
7 | }
8 | 


--------------------------------------------------------------------------------
/002_package/nested/hello/hello.go:
--------------------------------------------------------------------------------
1 | package hello
2 | 
3 | 
4 | func CallFromHello() string {
5 | 	return " hello golang! " + notVisible
6 | }


--------------------------------------------------------------------------------
/002_package/nested/hello/test.go:
--------------------------------------------------------------------------------
1 | package hello
2 | 
3 | var notVisible = "Not visible"


--------------------------------------------------------------------------------
/002_package/nested/nested.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"github.com/forgolang1/GoLangBasic/002_package/nested/say"
 5 | 	"github.com/forgolang1/GoLangBasic/002_package/nested/hello"
 6 | 	"fmt"
 7 | )
 8 | 
 9 | func main() {
10 | 
11 | 	fmt.Println("Start program...")
12 | 	fmt.Println(say.CallFromSay() + hello.CallFromHello())
13 | 
14 | }
15 | 


--------------------------------------------------------------------------------
/002_package/nested/say/say.go:
--------------------------------------------------------------------------------
1 | package say
2 | 
3 | func CallFromSay() string {
4 | 	return "Say"
5 | }
6 | 


--------------------------------------------------------------------------------
/002_package/simple/simple.go:
--------------------------------------------------------------------------------
1 | package main
2 | 
3 | import "fmt"
4 | 
5 | func main() {
6 | 	fmt.Println("Hello i am a simple packageScope!")
7 | }


--------------------------------------------------------------------------------
/003_variables/variables.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var a  = 5
 8 | 	var b, c  = "b", "c"
 9 | 	var d  = true
10 | 
11 | 	fmt.Printf("%T - %v\n", a, a)
12 | 	fmt.Printf("%T - %v\n", b, b)
13 | 	fmt.Printf("%T - %v\n", c, c)
14 | 	fmt.Printf("%T - %v\n", d, d)
15 | 
16 | 	e := 100
17 | 	e = 101
18 | 	f := "f"
19 | 	g := true
20 | 
21 | 	fmt.Printf("%T - %v\n", e, e)
22 | 	fmt.Printf("%T - %v\n", f, f)
23 | 	fmt.Printf("%T - %v\n", g, g)
24 | 
25 | 	var zeroInt int
26 | 	var emptyString string
27 | 	var boolFalse bool
28 | 
29 | 	fmt.Printf("%T - %v\n", zeroInt, zeroInt)
30 | 	fmt.Printf("%T - %v\n", emptyString, emptyString)
31 | 	fmt.Printf("%T - %v\n", boolFalse, boolFalse)
32 | 
33 | }
34 | 


--------------------------------------------------------------------------------
/004_variables_scope/closureScope/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	x := 100
 8 | 	fmt.Println(x)
 9 | 
10 | 	someFunc()
11 | 	someFuncTwo()
12 | 
13 | 	fmt.Println(miniGlobal)
14 | 
15 | 	dialog()
16 | }
17 | 
18 | func someFunc() {
19 | 	x := 150
20 | 	fmt.Println(x)
21 | 	fmt.Println(miniGlobal)
22 | }
23 | 
24 | func someFuncTwo() {
25 | 
26 | 	//fmt.Println(point)
27 | 	var test = "ok!"
28 | 	var point = 4.4
29 | 
30 | 	fmt.Println(test)
31 | 	fmt.Println(point)
32 | 
33 | }
34 | 
35 | var miniGlobal = true
36 | 
37 | func dialog() {
38 | 	var x = "Hi"
39 | 	var y = "Hello"
40 | 	fmt.Println(x)
41 | 	{
42 | 		fmt.Println(y)
43 | 		Z := "How are you?"
44 | 		fmt.Println(Z)
45 | 	}
46 | 	//fmt.Println(Z)
47 | }
48 | 


--------------------------------------------------------------------------------
/004_variables_scope/fileScope/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | var car = "ford"
 6 | 
 7 | func main()  {
 8 | 
 9 | 	fmt.Println(car)
10 | 	checkSpareWheel()
11 | 
12 | }
13 | 
14 | func checkSpareWheel() {
15 | 	if car == "ford" {
16 | 		fmt.Println("Spare wheel exist")
17 | 	}
18 | }
19 | 


--------------------------------------------------------------------------------
/004_variables_scope/packageScope/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"github.com/forgolang1/GoLangBasic/004_variables_scope/packageScope/nestedPackage"
 6 | )
 7 | 
 8 | func main() {
 9 | 
10 | 	//fmt.Println(nestedPackage.airplane)
11 | 	fmt.Println(nestedPackage.Airplane)
12 | 
13 | }


--------------------------------------------------------------------------------
/004_variables_scope/packageScope/nestedPackage/airplane.go:
--------------------------------------------------------------------------------
1 | package nestedPackage
2 | 
3 | 
4 | var airplaneName = "AIRBUS"
5 | var Airplane = "Jet"


--------------------------------------------------------------------------------
/005_constans/constans.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | const applicationName = "App Const"
 6 | 
 7 | const (
 8 | 	_ = iota //0
 9 | 	_ = iota
10 | 	_ = iota
11 | 	D = iota + 5 // 3 + 5
12 | 	E = iota     // 4
13 | )
14 | 
15 | func main() {
16 | 
17 | 	//fmt.Println(A)
18 | 	//fmt.Println(B)
19 | 	//fmt.Println(C)
20 | 	fmt.Println(D)
21 | 	fmt.Println(E)
22 | 
23 | 	const number = 100
24 | 	fmt.Println(applicationName)
25 | 	fmt.Println(number)
26 | 
27 | 	var numberTwo int = 10
28 | 	result := number + numberTwo
29 | 	fmt.Println(result)
30 | 
31 | 	x, _, _ := TypesGo()
32 | 	fmt.Println(x)
33 | 	//fmt.Println(y)
34 | 	//fmt.Println(z)
35 | 
36 | }
37 | 
38 | func TypesGo() (int, bool, string) {
39 | 	return 100, false, "stringType"
40 | }
41 | 


--------------------------------------------------------------------------------
/006_control_flow/for/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	for x:=1; x<100; x++ {
 8 | 
 9 | 		if x%10 == 0 {
10 | 			fmt.Println("%10", x)
11 | 			continue //прерываем текущую итерацию цикла for
12 | 			// break - остановка цикла
13 | 		}
14 | 
15 | 		fmt.Println(x)
16 | 	}
17 | }


--------------------------------------------------------------------------------
/006_control_flow/if/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main()  {
 6 | 
 7 | 	//if / else
 8 | 
 9 | 	a, b, c := 10, 20, 30
10 | 
11 | 
12 | 	if a > b {
13 | 		fmt.Println("a")
14 | 	} else if b < c {
15 | 		fmt.Println("b")
16 | 	} else {
17 | 		fmt.Println("c")
18 | 	}
19 | 
20 | }
21 | 


--------------------------------------------------------------------------------
/006_control_flow/switch/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var text = "Admin"
 8 | 
 9 | 	switch  {
10 | 	case text == "Admin" || text == "admin":
11 | 		fmt.Println("ok")
12 | 	default:
13 | 		fmt.Println("not ok")
14 | 
15 | 	}
16 | 
17 | 	switch text {
18 | 	case "word":
19 | 		fmt.Println("not admin")
20 | 	case "Admin":
21 | 		fmt.Println("Yeah - Admin")
22 | 	//fallthrough
23 | 	case "User":
24 | 		fmt.Println("not admin")
25 | 	default:
26 | 		fmt.Println("Some text")
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/007_array/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var array [5]int
 8 | 
 9 | 	array[0] = 100
10 | 	array[1] = 101
11 | 	array[2] = 102
12 | 
13 | 	//fmt.Println(array)
14 | 
15 | 	//for i:=0; i<len(array); i++ {
16 | 	//	fmt.Println(array[i])
17 | 	//}
18 | 
19 | 	for i, v := range array{
20 | 		fmt.Printf("Index - %v, Value - %v\n", i, v)
21 | 	}
22 | 
23 | 	var arrayTwo = [...]string{"a", "b"}
24 | 	var arrayThree = [...]string{"c", "b"}
25 | 	fmt.Println(len(arrayTwo))
26 | 
27 | 	fmt.Println(arrayThree == arrayTwo)
28 | 
29 | }


--------------------------------------------------------------------------------
/008_slices/difference.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	myArray := [5]int{10,20,30,40,50}
 8 | 	mySlice := []int{100,200,300,400,500}
 9 | 
10 | 	fmt.Printf("Array before do something %v\n", myArray)
11 | 	DoSomethingArray(myArray)
12 | 	fmt.Printf("Array after do something %v\n", myArray)
13 | 
14 | 	fmt.Printf("Slice before do something %v\n", mySlice)
15 | 	DoSomethingSlice(mySlice)
16 | 	fmt.Printf("Slice after do something %v\n", mySlice)
17 | 
18 | 
19 | }
20 | 
21 | func DoSomethingArray(array [5]int) {
22 | 	for i, _ := range array {
23 | 		array[i] += 500
24 | 	}
25 | 	fmt.Printf("Array after finish func %v\n", array)
26 | }
27 | 
28 | func DoSomethingSlice(slice []int) {
29 | 	for i, _ := range slice {
30 | 		slice[i] += 10000
31 | 	}
32 | 	fmt.Printf("Slice after finish func %v\n", slice)
33 | }


--------------------------------------------------------------------------------
/008_slices/slice.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var sliceOne []int
 8 | 	fmt.Println(len(sliceOne))
 9 | 	fmt.Println(cap(sliceOne))
10 | 
11 | 	sliceOne = append(sliceOne, 10)
12 | 	sliceOne = append(sliceOne, 20)
13 | 	sliceOne = append(sliceOne, 30)
14 | 	sliceOne = append(sliceOne, 40)
15 | 	sliceOne = append(sliceOne, 50)
16 | 
17 | 	fmt.Println(len(sliceOne))
18 | 	fmt.Println(cap(sliceOne))
19 | 
20 | 	fmt.Println(sliceOne[3:])
21 | 	fmt.Println(sliceOne[:3])
22 | 	fmt.Println(sliceOne[2:4])
23 | 	sliceOne[4] = 1000
24 | 
25 | 	//будет ошибка
26 | 	//sliceOne[5] = 19
27 | 
28 | 	fmt.Println(sliceOne)
29 | 
30 | 	slice := make([]int, 5, 19)
31 | 	fmt.Println(len(slice))
32 | 	fmt.Println(cap(slice))
33 | 	//fmt.Println(slice[5])
34 | 
35 | 
36 | 	x := []int{1,2,3}
37 | 	fmt.Println(x)
38 | }
39 | 


--------------------------------------------------------------------------------
/009_map/difference.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"strconv"
 5 | 	"fmt"
 6 | )
 7 | 
 8 | func main() {
 9 | 
10 | 
11 | 	var array [10]string
12 | 	for i:=0; i<len(array); i++ {
13 | 		array[i] = strconv.Itoa(i)
14 | 	}
15 | 
16 | 	var slice []string
17 | 	for i:=0; i<10; i++ {
18 | 		slice = append(slice, strconv.Itoa(i))
19 | 	}
20 | 
21 | 	myMap := make(map[int]string)
22 | 	for i:=0; i<10; i++ {
23 | 		myMap[i] = strconv.Itoa(i)
24 | 	}
25 | 
26 | 
27 | 	for i, v := range array{
28 | 		fmt.Printf("Array i %v - elem %v\n", i, v)
29 | 	}
30 | 
31 | 	fmt.Println("---")
32 | 
33 | 	for i, v := range slice{
34 | 		fmt.Printf("Slice i %v - elem %v\n", i, v)
35 | 	}
36 | 	fmt.Println("---")
37 | 
38 | 	for i, v := range myMap{
39 | 		fmt.Printf("Map i %v - elem %v\n", i, v)
40 | 	}
41 | }


--------------------------------------------------------------------------------
/009_map/map.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	var simpleMap = map[int]string{}
 8 | 	fmt.Println(simpleMap)
 9 | 	simpleMap[198] = "some word"
10 | 	fmt.Println(simpleMap)
11 | 
12 | 	var anotherMap = make(map[string]int)
13 | 	anotherMap["one"] = 198
14 | 	anotherMap["two"] = 1981
15 | 	anotherMap["three"] = 1982
16 | 	fmt.Println(anotherMap)
17 | 
18 | 	delete(anotherMap, "three")
19 | 	fmt.Println(anotherMap["two"])
20 | 
21 | 	slice := []int{1,2,4}
22 | 	//slice[6]
23 | 	for _, v := range slice {
24 | 		fmt.Println(v)
25 | 		if v == 2 {
26 | 			fmt.Println("ok")
27 | 		}
28 | 	}
29 | 
30 | 	if _ , ok := anotherMap["one"]; ok {
31 | 		//ok == true
32 | 		fmt.Println(anotherMap["one"])
33 | 	}
34 | 
35 | 	/*
36 | 	В отличии от array и slice - map всегда возвращает значение
37 | 	если идет обращение к несуществующему ключу то возвращается нулевое значение типа элемента мапы
38 | 	например
39 | 	fmt.Println(anotherMap["someJey"]) вернет 0
40 | 	 */
41 | 
42 | }


--------------------------------------------------------------------------------
/010_func/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	//sum(5, 2)
 8 | 	//fmt.Println(question("word"))
 9 | 
10 | 	//result, _ := someFunc(-1, 4, 323)
11 | 	//fmt.Println(result)
12 | 
13 | 	//someFuncTwo(10, 55)
14 | 	fmt.Println(onlyTypes(10, "23"))
15 | 
16 | 
17 | }
18 | 
19 | func sum(a int, b int) {
20 | 
21 | 	var z int
22 | 	z = a + b
23 | 	fmt.Println(z)
24 | 
25 | }
26 | 
27 | func question(q string) bool {
28 | 	if q == "question" {
29 | 		return true
30 | 	} else {
31 | 		return false
32 | 	}
33 | }
34 | 
35 | func someFunc(a, b, c int) (int, bool) {
36 | 	if a > 0 && b > 5 {
37 | 		return 10, true
38 | 	} else if c > 100 {
39 | 		return 100, true
40 | 	} else {
41 | 		return 0, false
42 | 	}
43 | }
44 | 
45 | func someFuncTwo(z, _ int) {
46 | 	fmt.Println(z)
47 | }
48 | 
49 | func onlyTypes(int, string) bool {
50 | 	return true
51 | }


--------------------------------------------------------------------------------
/011_closure/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main(){
 6 | 
 7 | 	//result := func(x, y int)(int){
 8 | 	//	return x+y
 9 | 	//}(10,20)
10 | 	//
11 | 	//fmt.Println(result)
12 | 	//fmt.Println(sum(1,3))
13 | 
14 | 	//closure("create a new text")
15 | 
16 | 	closure()
17 | 
18 | 	oneMore := func() int{
19 | 		z := closure() + 5
20 | 		return z
21 | 	}
22 | 
23 | 	fmt.Println(oneMore())
24 | 
25 | 
26 | 	//На 18 минуте 12 видеоурока - ошибка
27 | 	//печать значения 100 выполняется не в процессе выполнения кода
28 | 	//а за счет того что функция closure вызывается два раза
29 | 
30 | }
31 | 
32 | func closure() int {
33 | 
34 | 	t := 100
35 | 
36 | 	result := func() {
37 | 		fmt.Println(t)
38 | 	}
39 | 
40 | 	//t := 10
41 | 
42 | 	second := func() {
43 | 		fmt.Println(t)
44 | 	}
45 | 
46 | 	result()
47 | 	second()
48 | 
49 | 	return t
50 | 
51 | }
52 | 
53 | //func closure(s string) {
54 | //
55 | //	text := "sentence " + " - " + s
56 | //
57 | //	fmt.Println(text)
58 | //
59 | //	result := func() string{
60 | //		fmt.Println(text + "some another text")
61 | //		return text + "some another text"
62 | //	}
63 | //
64 | //	s = "_abc"
65 | //	sq := func() {
66 | //		fmt.Println("ahahah" + s)
67 | //	}
68 | //
69 | //	sq()
70 | //	fmt.Println(result())
71 | //
72 | //}
73 | 
74 | //func sum(a, b int) int {
75 | //
76 | //	func(s string){
77 | //		fmt.Println(s)
78 | //	}("some text")
79 | //
80 | //	return a + b
81 | //}
82 | 
83 | 


--------------------------------------------------------------------------------
/012_params/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | //...params
 6 | 
 7 | func main() {
 8 | 
 9 | 	sliceOfInt := [][]int{{34,35,38}, {1,2,1}}
10 | 
11 | 	value := calculate(sliceOfInt...)
12 | 	fmt.Println(value)
13 | }
14 | 
15 | func calculate(numbers ...[]int) int {
16 | 	result := 0
17 | 
18 | 	//fmt.Printf("%T", numbers)
19 | 
20 | 	for _, v := range numbers {
21 | 		for _, v2 := range v {
22 | 			result += v2
23 | 		}
24 | 	}
25 | 
26 | 	return result
27 | }


--------------------------------------------------------------------------------
/013_callback/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | //func main() {
 6 | //
 7 | //	t := calculate(100)
 8 | //
 9 | //	//t := func(k int) int {
10 | //	//	return k * 1000
11 | //	//}
12 | //
13 | //	z := t(5)
14 | //	fmt.Println(z)
15 | //
16 | //
17 | //}
18 | //
19 | //func calculate(i int) func(int)int {
20 | //	fmt.Println(i)
21 | //
22 | //	return func(k int) int {
23 | //		return k * 1000
24 | //	}
25 | //}
26 | 
27 | func calculate(numbers []int, justFunc func(int) int) int {
28 | 	result := 0
29 | 
30 | 	for _, n := range numbers {
31 | 		fmt.Println(justFunc(n))
32 | 
33 | 		result += justFunc(n)
34 | 	}
35 | 
36 | 	return result
37 | }
38 | 
39 | func main() {
40 | 	sOfInt := []int{1, 2, 3, 4}
41 | 
42 | 	x := calculate(sOfInt, func(n int) int {
43 | 		return n * 10
44 | 	})
45 | 
46 | 	fmt.Println(x)
47 | }
48 | 


--------------------------------------------------------------------------------
/014_defer/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | func main() {
 6 | 
 7 | 	defer theFour()
 8 | 	defer theThree()
 9 | 	defer theTwo()
10 | 	 theOne()
11 | 
12 | }
13 | 
14 | func theOne() {
15 | 	fmt.Println("One")
16 | }
17 | 
18 | func theTwo() {
19 | 	fmt.Println("Two")
20 | }
21 | 
22 | func theThree() {
23 | 	fmt.Println("Three")
24 | }
25 | 
26 | func theFour() {
27 | 	fmt.Println("Four")
28 | }
29 | 
30 | 


--------------------------------------------------------------------------------
/015_struct/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | type EDocument struct {
 8 | 
 9 | 	Number string
10 | 	Date string
11 | 	NumberOfPages int
12 | 	Footer
13 | 
14 | }
15 | 
16 | type Footer struct {
17 | 
18 | 	Author string
19 | 
20 | }
21 | 
22 | func main() {
23 | 
24 | 	doc1 := EDocument{
25 | 		Number: "001-A",
26 | 		Date: "10.09.2018",
27 | 		NumberOfPages: 10,
28 | 		Footer: Footer{
29 | 			Author: "Author-1",
30 | 		},
31 | 	}
32 | 
33 | 	var doc2 EDocument
34 | 	doc2.Number = "002-A"
35 | 	doc2.Date = "10.09.2018"
36 | 	doc2.NumberOfPages = 5
37 | 	doc2.Footer.Author = "Author-2"
38 | 
39 | 	fmt.Printf("%T - %v\n", doc1, doc1)
40 | 	fmt.Printf("%T - %v\n", doc2, doc2)
41 | 	fmt.Printf("%T - %v\n", doc2.Footer, doc2.Footer)
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/016_methods/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | type EDocument struct {
 8 | 
 9 | 	Number string
10 | 	Date string
11 | 	NumberOfPages int
12 | 	//Footer -- анонимное поле сразу определенное типом струкуры
13 | 	FooterDoc Footer //именованое поле с типом
14 | 
15 | }
16 | 
17 | type Footer struct {
18 | 	Author string
19 | }
20 | 
21 | 
22 | func (doc EDocument) showAuthor() {
23 | 	fmt.Println(doc.FooterDoc.Author)
24 | }
25 | 
26 | func (doc *EDocument) showNumberOfPages() {
27 | 	fmt.Println(doc.NumberOfPages)
28 | }
29 | 
30 | func (doc *EDocument) ClearAllPages() {
31 | 	doc.NumberOfPages = 0
32 | 	fmt.Println(doc.NumberOfPages)
33 | }
34 | 
35 | func (doc *EDocument) SetPrefixAuthor() {
36 | 	doc.FooterDoc.Author = " the Author is " + doc.FooterDoc.Author
37 | 	fmt.Println(doc.FooterDoc.Author)
38 | }
39 | 
40 | func main() {
41 | 
42 | 	doc1 := EDocument{
43 | 		Number: "001-A",
44 | 		Date: "10.09.2018",
45 | 		NumberOfPages: 10,
46 | 		FooterDoc: Footer{
47 | 			Author: "Author-1",
48 | 		},
49 | 	}
50 | 
51 | 	var doc2 EDocument
52 | 	doc2.Number = "002-A"
53 | 	doc2.Date = "10.09.2018"
54 | 	doc2.NumberOfPages = 5
55 | 	doc2.FooterDoc.Author = "Author-2"
56 | 
57 | 	doc3 := new(EDocument)
58 | 	doc3.Number = "003-B"
59 | 	doc3.Date = "23.09.2018"
60 | 	doc3.NumberOfPages = 7
61 | 	doc3.FooterDoc.Author = "No name"
62 | 
63 | 	//fmt.Printf("%T - %v\n", doc1, doc1)
64 | 	//fmt.Printf("%T - %v\n", doc2, doc2)
65 | 	//fmt.Printf("%T - %v\n", doc3, doc3)
66 | 	//fmt.Printf("%T - %v\n", doc2.FooterDoc, doc2.FooterDoc)
67 | 
68 | 	doc1.showAuthor()
69 | 	doc2.showAuthor()
70 | 	doc3.showAuthor()
71 | 
72 | 	doc1.ClearAllPages()
73 | 	doc2.ClearAllPages()
74 | 	doc3.ClearAllPages()
75 | 
76 | 	doc1.SetPrefixAuthor()
77 | 	doc2.SetPrefixAuthor()
78 | 	doc3.SetPrefixAuthor()
79 | }
80 | 
81 | 


--------------------------------------------------------------------------------
/017_interfaces/main.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "fmt"
 4 | 
 5 | /*
 6 | 
 7 |  Полиморфизм
 8 | 1 - Возможность объектов с одинаковой спецификацией иметь различную реализацию.
 9 | 
10 | 2 - Способность обьекта использовать методы производного класса
11 | 	который не существует на момент создания базового.
12 | 
13 | 3 - Это свойство классов иметь одинаковые методы,
14 | 	которые будут работать по-разному в контексте объектов.
15 | 
16 |  */
17 | 
18 | type Document struct {
19 | 	Date string
20 | 	Number string
21 | 	NumberOfPages int
22 | 
23 | }
24 | 
25 | type PersonCard struct {
26 | 	Date string
27 | 	FirstName string
28 | 	LastName string
29 | 	Age int
30 | }
31 | 
32 | type PrintInterface interface {
33 | 	CheckData()
34 | }
35 | 
36 | func (d *Document) CheckData() {
37 | 	//реализация функции интерфейса может быть произвольной для объекта структуры
38 | 	//главное соответсвие сигнатуре функции интерфейса
39 | 	if d.Date != "" {
40 | 		fmt.Println("Date in the doc - correct")
41 | 	} else {
42 | 		fmt.Println("Date in the doc - not correct")
43 | 	}
44 | }
45 | 
46 | func (p *PersonCard) CheckData() {
47 | 	if p.Date != "" {
48 | 		fmt.Println("Date in the person card - correct")
49 | 	} else {
50 | 		fmt.Println("Date in the person card - not correct")
51 | 	}
52 | }
53 | 
54 | 
55 | func main() {
56 | 
57 | 	doc := new(Document)
58 | 	pcard := new(PersonCard)
59 | 
60 | 	doc.Date = "1.10.2018"
61 | 	doc.NumberOfPages = 5
62 | 	doc.Number = "A - 100"
63 | 
64 | 	pcard.Date = "1.10.2018"
65 | 	pcard.Age = 21
66 | 	pcard.FirstName = "User"
67 | 	pcard.LastName = "Test"
68 | 
69 | 	sl := []PrintInterface{doc, pcard}
70 | 
71 | 	PrintAnyDoc(sl)
72 | 
73 | }
74 | 
75 | func PrintAnyDoc(anyDoc []PrintInterface) {
76 | 	for _, v := range anyDoc {
77 | 		fmt.Println(v)
78 | 	}
79 | }
80 | 
81 | 
82 | 


--------------------------------------------------------------------------------