tmp

go/stepik/3/json.go

@@ -0,0 +1,141 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+type myStruct struct {
+	Name   string
+	Age    int
+	Status bool
+	Values []int
+}
+
+func main() {
+	// foo1()
+	// decodeJson()
+	// testJson()
+	// foo2()
+	annotation()
+}
+
+func foo1() {
+	s := myStruct{
+		Name:   "John Connor",
+		Age:    35,
+		Status: true,
+		Values: []int{15, 11, 37},
+	}
+
+	data, err := json.Marshal(s)
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	fmt.Printf("%s", data)
+
+	newData, err := json.MarshalIndent(s, "", "\t")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	fmt.Printf("%s", newData)
+}
+
+func decodeJson() {
+	data := []byte(`{"Name":"John Connor","Age":35,"Status":true,"Values":[15,11,37]}`)
+
+	var s myStruct
+
+	if err := json.Unmarshal(data, &s); err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	fmt.Printf("%v", s)
+}
+
+// Проверка JSON на правильность.
+// Можем проверить является ли срез байтов форматом json.
+func testJson() {
+	type user struct {
+		Name     string
+		Email    string
+		Status   bool
+		Language []byte
+	}
+
+	m := user{Name: "John Connor", Email: "test email"}
+
+	data, _ := json.Marshal(m)
+
+	data = bytes.Trim(data, "{")
+
+	if !json.Valid(data) {
+		fmt.Println("invalid json!")
+	}
+
+	fmt.Printf("%s", data)
+}
+
+func foo2() {
+
+	type user struct {
+		Name     string
+		Email    string
+		Status   bool
+		Language []byte
+	}
+
+	newUser := user{
+		Name:     "Alex",
+		Email:    "email@email.email",
+		Status:   true,
+		Language: []byte("ru"),
+	}
+
+	data, err := json.Marshal(newUser)
+	if err != nil {
+		panic(err)
+	}
+
+	newUser.Language = []byte("en")
+	err = json.Unmarshal(data, &newUser)
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(string(newUser.Language))
+	// fmt.Println(data)
+	// fmt.Printf("%s", data)
+}
+
+func annotation() {
+	type myStruct struct {
+		// при кодировании / декодировании будет использовано имя name, а не Name
+		Name string `json:"name"`
+
+		// при кодировании / декодировании будет использовано то же имя (Age),
+		// но если значение поля равно 0 (пустое значение: false, nil, пустой слайс и пр.),
+		// то при кодировании оно будет опущено
+		Age int `json:",omitempty"`
+
+		// при кодировании . декодировании поле всегда игнорируется
+		Status bool `json:"-"`
+	}
+
+	m := myStruct{Name: "John Connor", Age: 0, Status: true}
+
+	data, err := json.Marshal(m)
+
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	fmt.Printf("%s", data) //
+}

go/stepik/3/json_data.json

@@ -0,0 +1,25 @@
+{
+    "ID":134,
+    "Number":"ИЛМ-1274",
+    "Year":2,
+    "Students":[
+        {
+            "LastName":"Вещий",
+            "FirstName":"Лифон",
+            "MiddleName":"Вениаминович",
+            "Birthday":"4апреля1970года",
+            "Address":"632432,г.Тобольск,ул.Киевская,дом6,квартира23",
+            "Phone":"+7(948)709-47-24",
+            "Rating":[1,2,3]
+        },
+        {
+            "LastName":"Ien",
+            "FirstName":"ccc",
+            "MiddleName":"Вениаминович",
+            "Birthday":"4апреля1970года",
+            "Address":"632432,г.Тобольск,ул.Киевская,дом6,квартира23",
+            "Phone":"+7(948)709-47-24",
+            "Rating":[5,2]
+        }
+    ]
+}

go/stepik/3/json_task.go

@@ -0,0 +1,136 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+)
+
+type Student struct {
+	LastName   string
+	FirstName  string
+	MiddleName string
+	Birthday   string
+	Address    string
+	Phone      string
+	Rating     []int
+}
+
+type Group struct {
+	ID       int
+	Number   string
+	Year     int
+	Students []Student
+}
+
+func main() {
+	// readJsonFromVar()
+	// readJsonFromFile()
+	readJsonFromStdin()
+}
+
+func readJsonFromStdin() {
+	var group Group
+	var markCount, studentCount int
+
+	data, err := io.ReadAll(os.Stdin)
+	if err != nil {
+		fmt.Println("Ошибка чтения")
+	}
+
+	if err := json.Unmarshal(data, &group); err != nil {
+		fmt.Println(err)
+	}
+
+	for _, val := range group.Students {
+		// for _, _ := range val.Rating {
+		markCount += len(val.Rating)
+		studentCount++
+	}
+
+	type Avr struct {
+		Average float32
+	}
+
+	avr := Avr{float32(markCount) / float32(studentCount)}
+	jsonData, err := json.MarshalIndent(avr, "", "    ")
+
+	io.WriteString(os.Stdout, string(jsonData))
+}
+
+func readJsonFromFile() {
+	file, err := os.Open("json_data.json")
+	if err != nil {
+		fmt.Printf("Ошибка открытия файла: %v\n", err)
+	}
+
+	defer func() {
+		if err := file.Close(); err != nil {
+			fmt.Printf("Ошибка закрытия файла %v\n", err)
+		} else {
+			fmt.Println("Файл закрыт")
+		}
+	}()
+
+	fileBytes, err := io.ReadAll(file)
+	if err != nil {
+		fmt.Printf("Ошибка чтения файла: %v\n", err)
+	}
+
+	var group Group
+
+	if err := json.Unmarshal(fileBytes, &group); err != nil {
+		fmt.Println(err)
+	}
+
+	var count, sum int
+
+	for _, val := range group.Students {
+		for _, mark := range val.Rating {
+			count++
+			sum += mark
+		}
+	}
+
+	// avr := fmt.Sprintf("%.1f", float32(sum)/float32(count))
+	// avr := float32(sum)/float32(count)
+	// var avr float32 = 12.3
+	// var jsonData []byte
+	type jd struct {
+		Average float32
+	}
+
+	jD := jd{15.43}
+
+	jsonData, err := json.MarshalIndent(jD, "", "    ")
+
+	/*
+		if jsonData, err := json.Marshal(avr); err != nil {
+			fmt.Printf("Что-то пошло не так")
+		}
+	*/
+	fmt.Println(jsonData)
+	fmt.Println(string(jsonData))
+	// fmt.Println(avr)
+
+	// fmt.Println(float32(sum) / float32(count))
+
+}
+
+// Создали тестовый массив байт в виде JSON и
+// распарсили его в структуру.
+func readJsonFromVar() {
+	testInput := []byte(`{
+	"ID": 134,
+	"Number": "ИЛМ-1274",
+	"Year": 2}`)
+
+	var group Group
+
+	if err := json.Unmarshal(testInput, &group); err != nil {
+		fmt.Println(err)
+	} else {
+		fmt.Println(group.ID, group.Number, group.Year)
+	}
+}

go/stepik/3/time.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+func main() {
+	// Получаем текущее время
+	now := time.Now()
+
+	// Создаем времч с помощью конкретных значений
+	currentTime := time.Date(
+		2020,
+		time.May,
+		15, // день
+		10, // часы
+		13, // минуты
+		12, // секунды
+		45, // наносекунды
+		time.UTC,
+	)
+
+	// Создаем время, используя секунды и наносекунды, прошедшие с начала эпохи Unix
+	unixTime := time.Unix(
+		150000, // секунды
+		1,      // наносекунды
+	)
+
+	// 01-02 03:04.05 0006 15
+	// день месяц час(12) минуты секунды год час(24)
+
+	// Форматируем и выводим время в строковом виде
+	// fmt.Println(now.Format("02-01-2006 15:04:05"))
+	fmt.Println(now.Format("02-01-2006 15:04:05"))
+	fmt.Println(currentTime.Format("02-01-2006 15:04:05"))
+	fmt.Println(unixTime.Format("02-01-2006 15:04:05"))
+
+	// Функция Parse парсит строку в соответствии с заданным шаблоном
+	firstTime, err := time.Parse("2006/01/02 15-04", "2020/05/15 17-45")
+	if err != nil {
+		panic(err)
+	}
+
+	fmt.Println(firstTime.Format("00-00-0000 00:00:00"))
+}