go

courses/golang_web/data_type/1/array.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+	// размер массива являются часть его типа
+	// массив размера 2 и массив размера 3 - это разные типы данных
+	// для определения размера массива можно использовать константы,
+	// но не переменные
+
+	var a1 [3]int // [0, 0, 0]
+	fmt.Println("a1 short", a1)
+	fmt.Printf("a1 short %v\n", a1)
+	fmt.Printf("a1 full %#v\n", a1)
+
+	const size = 2
+	var a2 [2 * size]bool // [false, false, false, false]
+	fmt.Println("a2", a2)
+
+	// определение размера при объявлении
+	a3 := [...]int{1, 2, 3}
+	fmt.Println("a3", a3)
+
+}

courses/golang_web/data_type/1/condition.go

@@ -0,0 +1,63 @@
+package main
+
+import "fmt"
+
+func main() {
+	// просто условие
+	boolVal := true
+	if boolVal {
+		fmt.Println("boolVal is true")
+	}
+
+	mapVal := map[string]string{"name": "rvasily"}
+	// условие с блоком инициализации
+	if keyValue, keyExist := mapVal["name"]; keyExist {
+		fmt.Println("name = ", keyValue)
+	}
+
+	// подучаем т`олько признак существования ключа
+	if keyValue, keyExist := mapVal["name"]; keyExist {
+		fmt.Println("key 'name' exist")
+	}
+
+	cond := 1
+	// множественный if else
+	if cond == 1 {
+		fmt.Println("cond is 1")
+	} else if cond == 2 {
+		fmt.Println("cond is 2")
+	}
+
+	// switch по 1 переменной
+	strVal := "name"
+	switch strVal {
+	case "name":
+		fallthrough
+	case "test", "lastName":
+		// some work
+	default:
+		// some work
+	}
+
+	// switch как замена многим ifelse
+	var val1, val2 = 2, 2
+	switch {
+	case val1 > 1 || val2 < 11:
+		fmt.Println("first block")
+	case val2 > 10:
+		fmt.Println("second block")
+	}
+
+Loop:
+	for key, val := range mapVal {
+		fmt.Println("switch in loop", key, val)
+		switch {
+		case key == "lastName":
+			break
+			fmt.Println("dont print this")
+		case key == "fitstName" && val == "Vasily":
+			fmt.Println("switch - break loop here")
+			break Loop // чтобы завершить цикл, нужно поставить метку
+		}
+	} // конц for
+}

courses/golang_web/data_type/1/const.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"fmt"
+)
+
+const pi = 3.141
+
+// Блок констант
+const (
+	hello = "Привет"
+	e     = 2.418
+)
+
+const (
+	zero = iota
+	_    // пустая переменная, пропуск iota
+	two  // = 2
+	three
+)
+
+const (
+	_         = iota
+	KB uint64 = 1 << (10 * iota)
+)
+
+const (
+	// нетипизирванная константа
+	year = 2017
+	// типизированная константа
+	yearTyped int = 2017
+)
+
+func main() {
+	var month int32 = 13
+	fmt.Println(month + year)
+
+	// fmt.Println(two)
+	// fmt.Println(three)
+}

courses/golang_web/data_type/1/loop.go

@@ -0,0 +1,72 @@
+package main
+
+import "fmt"
+
+func main() {
+	// цикл без условия, while(true) or for(;;;)
+	for {
+		fmt.Println("loop iteration")
+		break
+	}
+
+	// цикл без условия, while(isRun)
+	isRun := true
+	for isRun {
+		fmt.Println("loop iteration  with condition")
+		isRun = false
+	}
+
+	// цикл с условием и блоком инициализации
+	for i := 0; i < 2; i++ {
+		fmt.Println("loop iteration", i)
+		if i == 1 {
+			continue
+		}
+	}
+
+	// операции со slice
+	sl := []int{1, 2, 3}
+	idx := 0
+
+	for idx < len(sl) {
+		fmt.Println(idx, sl[idx])
+		idx++
+	}
+
+	for i := 0; i < len(sl); i++ {
+		fmt.Println("c-syle loop", i, sl[i])
+	}
+
+	// здесь range возвращает только индекс
+	for idx := range sl {
+		fmt.Println("range slice by index", idx)
+	}
+
+	// а здесь range вернет индекс и копию значения
+	for idx, val := range sl {
+		fmt.Println("range slice by idx-value", idx, val)
+	}
+
+	// операции по map
+	profile := map[int]string{1: "Vasily", 2: "Romanov"}
+
+	// Но ключи в map могут быть в разном порядке от запуска к запуску
+	for key := range profile {
+		fmt.Println(key)
+	}
+
+	for key, val := range profile {
+		fmt.Println(key, val)
+	}
+
+	for _, val := range profile {
+		fmt.Println(val)
+	}
+
+	// итерация по строке - итерация по отдельным символам
+	str := "Привет, Мир!"
+	for pos, char := range str {
+		fmt.Printf("%#U at pos %d\n", char, pos)
+	}
+
+}

courses/golang_web/data_type/1/map.go

@@ -0,0 +1,36 @@
+package main
+
+import "fmt"
+
+func main() {
+	// инициализация при создании
+	// [тип ключа]тип данных
+	var user map[string]string = map[string]string{
+		"name":     "Vasiliy",
+		"lastName": "Romanov",
+	}
+
+	// сразу с нужной емкостью
+	profile := make(map[string]string, 10)
+
+	// количество элементов
+	mapLength := len(user)
+
+	fmt.Printf("%d %+v\n", mapLength, profile)
+
+	// если ключа нет - вернет значение по умолчанию для типа
+	mName := user["middleName"]
+	fmt.Println("mName:", mName)
+
+	// проверка на существование ключа
+	mName, mNameExist := user["middleName"]
+	fmt.Println("mName:", mName, "mNameExist", mNameExist)
+
+	// пустая переменная - только проверяем что ключ есть
+	_, mNameExist2 := user["middleName"]
+	fmt.Println("mNameExist2", mNameExist2)
+
+	// удаление ключа
+	delete(user, "lastName")
+	fmt.Printf("%#v\n", user)
+}

courses/golang_web/data_type/1/pointer.go

@@ -0,0 +1,23 @@
+package main
+
+/*
+Указатель - отдельный тип данных
+В указателе лежит значение адреса где лежит другая переменная
+*/
+
+func main() {
+	a := 2
+	b := &a
+	*b = 3 // a = 3
+	c = &a // новый указатель на переменную a
+
+	// получение указателя на переменную типа int
+	// инициализировано значением по-умолчанию
+	d := new(int)
+	*d = 12
+	*c = *d // c = 12 -> a = 12
+	*d = 13 // с и а не изменились
+
+	c = d   // теперь с указывает туда же, куда d
+	*с = 14 // с = 14 -> d = 14, a = 12
+}

courses/golang_web/data_type/1/slice.go

@@ -0,0 +1,86 @@
+package main
+
+import "fmt"
+
+func main() {
+	// len - размер слайса
+	// cap - сколько аллоцировано памяти под слайс
+
+	// создание
+	var buf0 []int             // len = 0, cap = 0
+	buf1 := []int{}            // len = 0, cap = 0
+	buf2 := []int{42}          // len = 1, cap = 1
+	buf3 := make([]int, 0)     // len = 0, cap = 0
+	buf4 := make([]int, 5)     // len = 5, cap = 5
+	buf5 := make([]int, 5, 10) // len = 5, cap = 10
+
+	fmt.Println(buf0, buf1, buf2, buf3, buf4, buf5)
+
+	// ошибка при выполнении
+	// panic: runtime error: index out of range
+	// someOtherInt := buf2[1]
+
+	someInt := buf2[0]
+	fmt.Println(someInt)
+
+	// добавление элементов
+	var buf []int            // len = 0, cap = 0
+	buf = append(buf, 9, 10) // len = 2, cap = 2
+	buf = append(buf, 12)    // len = 3, cap = 4
+
+	// добавление другого слайса
+	otherBuf := make([]int, 3)     // [0, 0, 0]
+	buf = append(buf, otherBuf...) // len =6, cap = 8
+
+	fmt.Println(buf, otherBuf)
+
+	// просмотр информации о слайсе
+	var bufLen, bufCap int = len(buf), cap(buf)
+
+	fmt.Println(bufLen, bufCap)
+
+	test1()
+}
+
+func test1() {
+	// получение среза, указывающего на ту же память
+	sl1 := buf[1:4] // [2, 3, 4]
+	sl2 := buf[:2]  // [1, 2]
+	sl3 := buf[2:]  // [3, 4, 5]
+	fmt.Println(sl1, sl2, sl3)
+
+	// Создать новый слайс - копия buf
+	newBuf := buf[:] // [1, 2, 3, 4, 5]
+	// изменив newBuf, buf тоже изменится
+	// buf = [9, 2, 3, 4, 5], т.к. та же память
+	newBuf[0] = 9
+
+	// newBuf теперь указывает на другие данные
+	newBuf = append(newBuf, 6)
+
+	// при увеличении размера buf (дабвление данных)
+	// он скопируется в другую область памяти,
+	// И поэтому buf НЕ ИЗМЕНИТСЯ!!!!!
+
+	// buf    = [9, 2, 3, 4, 5], не изменился
+	// newBuf = [1, 2, 3, 4, 5, 6], изменился
+	newBuf[0] = 1
+	fmt.Println("buf", buf)
+	fmt.Println("newBuf", newBuf)
+
+	// копирование одного слайса в другой
+	var emptyBuf []int // len=0, cap=0
+	// неправильно - скопирует меньшее (по len) из 2-х слайсов
+	copied := copy(emptyBuf, buf) // copied = 0
+	fmt.Println(copied, emptyBuf)
+
+	// правильно
+	newBuf = make([]int, len(buf), len(buf))
+	copy(newBuf, buf)
+	fmt.Println(newBuf)
+
+	// можно копировать в часть существующего слайса
+	ints := []int{1, 2, 3, 4}
+	copy(ints[1:3], []int{5, 6}) // ints = [1, 5, 6, 4]
+	fmt.Println(ints)
+}

courses/golang_web/data_type/1/typedef.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+type UserID int
+
+func main() {
+	idx := 1
+	var uid UserID = 42
+
+	// дажу если базовый тип одинаковый, разные типы несовместимы
+	// cannot use uid (type UserID) as type int64 in assigment
+	// myID := idx
+
+	myID := UserID(idx)
+
+	fmt.Println(uid, myID)
+
+}

courses/golang_web/data_type/main.go → courses/golang_web/data_type/1/vars.go

@@ -1,6 +1,9 @@
 package main
 
-import "fmt"
+import (
+	"fmt"
+	"unicode/utf8"
+)
 
 func main() {
 	// значение по умолчанию
@@ -42,7 +45,7 @@ func main() {
 	weight, age := 12, 22
 
 	fmt.Println(weight, height, age)
-	dataType()
+	//dataType()
 }
 
 func dataTypeDigit() {
@@ -71,18 +74,19 @@ func dataTypeDigit() {
 	fmt.Println(pi, e, goldenRatio)
 
 	// bool
-	var b bool // false по-умолчанию
+	var b bool // false по-умолчан
 	var isOk bool = true
 	var success = true
 	cond := true
-	
+
 	fmt.Println(b, isOk, success, cond)
 
 	// complex64, complex128
-	var c complex128 = -1.1 + 7.12i
-	c2 := -1.1 + 7.12i
+	//var c complex128 = -1.1 + 7.12i
+	//c2 := -1.1 + 7.12i
 }
 
+
 func dataTypeString()
 {
 	// пустая строка по умолчанию
@@ -91,4 +95,35 @@ func dataTypeString()
 	// со спец символами
 	var hello string = "Привет\n\r"
 
-}
+	// без спец символов
+	var world string = `Мир\r\n`
+
+	// UTF-8 из коробки
+	var hellowWorld = "Привет, мир!"
+
+	// одинарные кавычки для байт (uint8)
+	var rawBinary byte = '\x27'
+
+	// rune (uint32) для UTF-8 символов
+
+	// конкатенация строк
+	andGoodMorning := helloWorld + " и доброе утро"
+
+	// строки неизменяемы
+	// helloWorld[0] = 72
+
+	// получение длины строки (возыращает длину в байтах)
+	byteLen := len(hellowWorld)
+	sybols := utf8.RuneCountInString(hellowWorld)
+
+	// получение подстроки, в байтах, не символах!
+	hello := hellowWorld[:12] // Привет, 0-11 байты
+	H := hellowWorld[0]	// byte, 72, не "П"
+
+	// конвертация в слайс байт и обратно
+	byteString = []byte(hellowWorld)
+	helloWorld = string(byteString)
+
+	
+}
+