tmp

go/stepik/3/error_interface.go

@@ -0,0 +1,32 @@
+package main
+
+import (
+	"fmt"
+	"unicode"
+)
+
+type customError uint
+
+func (c customError) Error() string {
+	return fmt.Sprintf("цифра, индекс %d", c)
+}
+
+func errorInString(str string) error {
+	// Полезная работа со строкой проигнорирована
+	for i, s := range str {
+		if unicode.IsDigit(s) {
+			return customError(i)
+		}
+	}
+	return nil
+}
+
+func main() {
+	err := errorInString("string1string")
+	if err != nil {
+		fmt.Printf("Ошибка обработана: %v\n", err)
+	}
+	if cError, ok := err.(customError); ok {
+		fmt.Printf("Контекст: %d\n", cError)
+	}
+}

go/stepik/3/interface.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+)
+
+/*
+1. Интерфейс является контрактом определяющим методы,
+которым обязан обладать объект и объявляется через type
+
+type Reader interface {
+	Read(p []byte) (n int, err error)
+}
+
+2. Интерфейс может быть пустым с любым типом и
+объявляться через var
+var i interface{} = 12
+
+3. Интерфейс может быть списком разных типов данных
+var randomsArray = [5]interface{}{"Hello world", 32, false, 33.22, 'A'}
+
+4. Интерфейс можно попытаться привести к нужному типу
+var i interface{} = 12
+v, ok := i.(int); ok
+
+5. Можно получить тип объекта присвоенного интерфейсу
+i.(type)
+
+*/
+
+func main() {
+	// specialPrint(10, 4, 5, 8, 7)
+	// empty()
+	do(21)
+	do("hello")
+	do(true)
+}
+
+func specialPrint(arg ...int) error {
+	if _, err := fmt.Print(arg); err != nil {
+		return err
+	}
+	return nil
+}
+
+func empty() {
+	var i interface{} = 12
+
+	if v, ok := i.(int); ok {
+		fmt.Println(v + 12)
+	}
+}
+
+func do(i interface{}) {
+	switch v := i.(type) {
+	case int:
+		fmt.Println("Умножим на 2:", v*2)
+	case string:
+		fmt.Println(v + " golang")
+	default:
+		fmt.Printf("Я не знаю такого типа %T!\n", v)
+	}
+}

go/stepik/3/interface_task.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	foo1()
+	/*
+		value1, value2, operation := readTask()
+
+		switch v1 := value1.(type) {
+		case float64:
+			break
+		default:
+			fmt.Printf("value=%v: %T\n", v1, v1)
+			return
+		}
+
+		switch v2 := value2.(type) {
+		case float64:
+			break
+		default:
+			fmt.Printf("value=%v: %T\n", v2, v2)
+			return
+		}
+
+		switch op := operation.(type) {
+		case string:
+			if op == "+" {
+				fmt.Printf("%.4f\n", value1.(float64)+value2.(float64))
+			} else if op == "-" {
+				fmt.Printf("%.4f\n", value1.(float64)-value2.(float64))
+			} else if op == "*" {
+				fmt.Printf("%.4f\n", value1.(float64)*value2.(float64))
+			} else if op == "/" {
+				fmt.Printf("%.4f\n", value1.(float64)/value2.(float64))
+			}
+		default:
+			fmt.Printf("operation=%v: %T\n", op, op)
+			return
+		}
+
+		// fmt.Println("value 1 - OK")
+		// fmt.Println(value1, value2, operation)
+	*/
+}
+
+func foo1() {
+	// vi1, vi2, operation :=  readTask()
+	// vi := [2]interface{}{vi1, vi2}
+	var v1, v2 float64
+	vf := [2]*float64{&v1, &v2}
+	fmt.Println(vf)
+	fmt.Printf("%v %T", vf, vf)
+}
+
+func readTask() (v1, v2, op interface{}) {
+	v1 = 12.36
+	v2 = 36.24
+	op = "+"
+	return
+}