Merge branch 'master' of dtelenkov:Home/codewars

go/stepik/course_1/4/client.go

@@ -0,0 +1,47 @@
+package main
+
+import (
+	"fmt"
+	"net"
+	"strings"
+)
+
+func main() {
+	foo1()
+}
+
+func foo1() {
+	conn, err := net.Dial("tcp", "localhost:8081")
+	if err != nil {
+		fmt.Println("err")
+	}
+	defer conn.Close()
+
+	message := make([]byte, 1024)
+
+	for i := 0; i < 3; i++ {
+		n, err := conn.Read(message)
+		if err != nil {
+			fmt.Println(err)
+		}
+		fmt.Println(strings.ToUpper(string(message[:n])))
+	}
+
+	/*
+		// Подключенине к серверу
+		conn, err := net.Dial("tcp", "142.251.39.142:80")
+		if err != nil {
+			log.Println(err)
+		}
+		defer conn.Close()
+
+		// Чтение данных с сервера
+		message := make([]byte, 1024) // создаем буфер
+		n, err := conn.Read(message)
+		if err != nil {
+			log.Println(err)
+		}
+		fmt.Println(string(message[:n]))
+	*/
+
+}

go/stepik/course_1/4/handler.go

@@ -0,0 +1,45 @@
+package main
+
+import (
+	"log"
+	"net/http"
+	"time"
+)
+
+type timeHandler struct {
+	format string
+}
+
+func (th *timeHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	tm := time.Now().Format(th.format)
+	w.Write([]byte("The time is: " + tm))
+}
+
+func handler(w http.ResponseWriter, r *http.Request) {
+	w.Write([]byte("OK!"))
+}
+
+func main() {
+	/*
+		// создаем свой serveMux
+		serveMux := http.NewServeMux()
+		serveMux.HandleFunc("/", handler)
+		// Запускаем веб-сервер на порту 8080 с нашим serveMux
+		// (в прошлых примерах был nil)
+		err := http.ListenAndServe(":8080" serverMux)
+		if err != nil {
+			fmt.Println("Ошибка запуска сервера:", err)
+		}
+	*/
+
+	mux := http.NewServeMux()
+
+	th1123 := &timeHandler{format: time.RFC1123}
+	mux.Handle("/time/rfc1123", th1123)
+
+	th3339 := &timeHandler{format: time.RFC3339}
+	mux.Handle("/time/rfc3339", th3339)
+
+	log.Println("Listening...")
+	http.ListenAndServe(":3000", mux)
+}

go/stepik/course_1/4/net.go

@@ -0,0 +1,106 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"os"
+	"time"
+)
+
+func main() {
+	// client()
+	// server()
+	testServer()
+}
+
+func testServer() {
+	listener, err := net.Listen("tcp", "localhost:8081")
+	if err != nil {
+		log.Println(err)
+	}
+	conn, err := listener.Accept()
+	if err != nil {
+		log.Println(err)
+	}
+	defer conn.Close()
+
+	conn.Write([]byte("message"))
+	time.Sleep(10)
+	conn.Write([]byte("mesSaGe"))
+	time.Sleep(10)
+	conn.Write([]byte("MESSAGE"))
+}
+
+func client() {
+	// Подключенине к серверу
+	conn, err := net.Dial("tcp", "142.251.39.142:80")
+	if err != nil {
+		log.Println(err)
+	}
+	defer conn.Close()
+
+	// Чтение данных с сервера
+	message := make([]byte, 1024) // создаем буфер
+	n, err := conn.Read(message)
+	if err != nil {
+		log.Println(err)
+	}
+	fmt.Println(string(message[:n]))
+
+	// Вывод данных в консоль
+	io.Copy(os.Stdout, conn)
+}
+
+func server() {
+
+	listener, err := net.Listen("tcp", "localhost:80")
+	if err != nil {
+		fmt.Println("Error:", err)
+		return
+	}
+	defer listener.Close()
+	/*
+		for {
+			conn, err := listener.Accept()
+			if err != nil {
+				fmt.Println("Error:", err)
+				continue
+			}
+			go handleConnection(conn)
+		}
+	*/
+	/*
+		// Создаём слушатель для порта
+		ln, err := net.Listen("tcp", "localhost:80")
+		if err != nil {
+			log.Println(err)
+		}
+		defer ln.Close()
+
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				log.Fatal(err)
+			}
+
+			go func(c net.Conn) {
+				io.Copy(c, c)
+				c.Close()
+			}(conn)
+		}
+	*/
+
+	/*
+		// Принимаем входящие подключения
+		conn, err := ln.Accept()
+		if err != nil {
+			log.Println(err)
+		}
+		_, err = conn.Write([]byte("message"))
+		if err != nil {
+			log.Println(err)
+		}
+	*/
+}

go/stepik/course_1/4/net_http.go

@@ -0,0 +1,201 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+)
+
+// User - структура для представления объекта пользователя
+type User struct {
+	Name string `json:"name"`
+	ID   uint32 `json:"id"`
+}
+
+type Output struct {
+	JSON struct {
+		Name string `json:"name"`
+		ID   uint32 `json:"id"`
+	} `json:"json"`
+	URL string `json:"usr"`
+}
+
+func main() {
+	// foo1()
+	// postFormExample()
+	queryExample()
+}
+
+func foo1() {
+	// Создаем экземпляр структуры User
+	var u = User{
+		Name: "Alex",
+		ID:   1,
+	}
+
+	// Кодируем структуру User в JSON (байтовый срез)
+	bytesRepresentation, err := json.Marshal(u)
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	// Отправляем POST-запрос на сервер с JSON-телом
+	resp, err := http.Post("https://httpbin.org/post", "application/json", bytes.NewBuffer(bytesRepresentation))
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	// Читаем и конвертируем тело ответа в байты
+	bytesResp, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// Выводим содержимое тела ответа
+	// fmt.Println(string(bytesResp))
+
+	// Создаем экземпляр ответа сервера
+	var out Output
+	// Декодируем данные в формате JSON и заполняем структуру
+	err = json.Unmarshal(bytesResp, &out)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	fmt.Printf("%+v\n", out)
+	fmt.Println(out.URL)
+
+	/*
+	   var st string
+
+	   json.Unmarshal(bytesRepresentation, &st)
+
+	   fmt.Println(st)
+	*/
+}
+
+// Отправка данных в виде формы
+func postFormExample() {
+	formData := url.Values{
+		"name":     {"hello"},
+		"surename": {"golang post form"},
+	}
+
+	resp, err := http.PostForm("https://httpbin.org/post", formData)
+	if err != nil {
+		log.Fatalln(err)
+	}
+
+	var result map[string]interface{}
+
+	json.NewDecoder(resp.Body).Decode(&result)
+
+	log.Println(result["form"])
+
+	fmt.Println("OK")
+}
+
+func queryExample() {
+	// Создаем URL с параметрами
+	baseURL := "https://example.com/api/resource"
+	params := url.Values{}
+	params.Add("param1", "value1")
+	params.Add("param2", "value2")
+
+	fullURL := baseURL + "?" + params.Encode()
+
+	fmt.Println(fullURL)
+
+	// Отправляем GET-запрос
+	response, err := http.Get(fullURL)
+	if err != nil {
+		fmt.Println("Ошибка при отправлке GET-запроса:", err)
+		return
+	}
+	defer response.Body.Close()
+
+	// Чтение ответа
+	// ...
+
+	// Обработка ответа
+	// ...
+
+}
+
+// http.NewRequest()
+
+// Todo - структура для представления объекта Todo
+type Todo struct {
+	UserID   int    `json:"userId"`
+	ID       int    `json:"id"`
+	Title    string `json:"title"`
+	Complete bool   `json:"completed"`
+}
+
+func newRequestExample() {
+	todo := Todo{
+		UserID:   1,
+		ID:       2,
+		Title:    "наш title",
+		Complete: true,
+	}
+
+	// Кодируем структуру Todo в формат JSON
+	jsonReq, err := json.Marshal(todo)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	// URL сервера
+	baseURL := "https://jsonplaceholder.typicode.com/posts/1"
+
+	// Создаем новый HTTP-запрос с методом POST
+	req, err := http.NewRequest("POST", baseURL, bytes.NewBuffer(jsonReq))
+	if err != nil {
+		log.Println("Ошибка при создании запроса:", err)
+		return
+	}
+
+	// Устанавливаем заголовки запроса
+	req.Header.Set("Content-Type", "application/json; charset=UTF-8")
+
+	// Отправляем запрос
+	client := &http.Client{}        // Создаем http клиент
+	response, err := client.Do(req) // передаем выше подготовленный запрос на отправку
+	if err != nil {
+		log.Println("Ошибка при выполнении запроса: ", err)
+		return
+	}
+
+	defer response.Body.Close() // не забываем закрыть тело
+
+	// Читаем и конвертируем тело ответа в байты
+	bodyBytes, err := io.ReadAll(response.Body)
+	if err != nil {
+		log.Println(err)
+	}
+
+	// Конвертируем тело ответа в строку и выводим
+	bodyString := string(bodyBytes)
+	fmt.Printf("API ответ в форме строки: %s\n", bodyString)
+
+	// Конвертируем тело ответа в Todo struct
+	var todoStruct Todo
+	err = json.Unmarshal(bodyBytes, &todoStruct)
+	if err != nil {
+		log.Println(err)
+	}
+
+	// Выводим структуру
+	fmt.Printf("API ответ в форме struct:\n%+v\n", todoStruct)
+
+	// Вывод статуса ответа (если 200 - то успешный)
+	fmt.Println("Статус ответа:", response.Status)
+}

go/stepik/course_1/4/net_task.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+)
+
+func main() {
+	// testRequest()
+	testQuery()
+}
+
+// http://127.0.0.1:5555/get
+func testRequest() {
+	// resp, err := http.Get("http://google.com/")
+	resp, err := http.Get("http://127.0.0.1:5555")
+	if err != nil {
+		fmt.Println("error")
+	}
+	defer resp.Body.Close()
+	fmt.Println("~~~~~~~~~~~~~~~~")
+	fmt.Println(resp)
+	/*
+	   fmt.Println("~~~~~~~~~~~~~~~~")
+	   fmt.Println(resp.Body)
+
+	   bytesResp, err := io.ReadAll(resp.Body)
+	   fmt.Println(bytesResp)
+	   fmt.Println("~~~~~~~~~~~~~~~~")
+	   fmt.Println(string(bytesResp))
+	*/
+}
+
+func testQuery() {
+	var name, age string
+
+	fmt.Scan(&name)
+	fmt.Scan(&age)
+
+	baseURL := "http://127.0.0.1:8080/hello"
+	params := url.Values{}
+	params.Add("name", name)
+	params.Add("age", age)
+	fullURL := baseURL + "?" + params.Encode()
+
+	resp, err := http.Get(fullURL)
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	defer resp.Body.Close()
+
+	data, err := io.ReadAll(resp.Body) // читаем ответ
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	fmt.Printf("%s", data) // печатаем ответ как строку
+}

go/stepik/course_1/4/server1.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+// Обработчик HTTP-запросов
+func handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Println(r.Method) // Тип метода
+	fmt.Println(r.URL)    // запрашиваемый URL
+	// fmt.Println(r.Proto)  // версия протокола
+	w.Write([]byte("Hello!"))
+}
+
+func main() {
+	// Регистрируем обработчик для пути "/"
+	http.HandleFunc("/", handler)
+
+	// Запускаем веб-сервер на порту 8080
+	err := http.ListenAndServe(":8080", nil)
+	if err != nil {
+		fmt.Println("Ошибка запуска сервера:", err)
+	}
+}
+
+func handleRequest(w http.ResponseWriter, r *http.Request) {
+	// В зависимости от метода HTTP-запроса вызываем соответствующий обработчик
+	switch r.Method {
+	case http.MethodGet:
+		handleGET(w, r)
+	case http.MethodPost:
+		handlePOST(w, r)
+	case http.MethodPut:
+		handlePUT(w, r)
+	case http.MethodDelete:
+		handleDELETE(w, r)
+	default:
+		http.Error(w, "Метод не поддерживается", http.StatusMethodNotAllowed)
+	}
+}
+
+// Обработчик для GET-запросов
+func handleGET(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintln(w, "Это GET-запрос!")
+}
+
+// Обработчик для POST-запросов
+func handlePOST(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintln(w, "Это POST-запрос!")
+}
+
+// Обработчик для PUT-запросов
+func handlePUT(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintln(w, "Это PUT-запрос!")
+}
+
+// Обработчик для DELETE-запросов
+func handleDELETE(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintln(w, "Это DELETE-запрос!")
+}

go/stepik/course_1/4/server2.go

@@ -0,0 +1,92 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+)
+
+// Обработчик HTTP-запросов
+/*
+func handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("RawQuery: ", r.URL.String())
+	fmt.Println("Name: ", r.URL.Query().Get("name"))
+	fmt.Println("IsExist: ", r.URL.Query().Has("name"))
+	w.Write([]byte("Привет, Stepik!"))
+}
+*/
+
+func main() {
+
+	// server2()
+	server3()
+	/*
+		// Регистрируем обработчик для пути "/"
+		http.HandleFunc("/", handler)
+
+		// Запускаем веб-сервер на порту 8080
+		err := http.ListenAndServe(":8080", nil)
+		if err != nil {
+			fmt.Println("Ошибка запуска сервера:", err)
+		}
+	*/
+}
+
+// Веб сервер по пути /body принимает запрос и проверяет что он
+// является POST методом. Далее читаем тело через уже знакомую
+// функцию io.ReadAll()
+
+func handlerBody(w http.ResponseWriter, r *http.Request) {
+	// Проверяем что метод POST
+	if r.Method == "POST" {
+		// читаем входящее тело запроса
+		bytesBody, err := io.ReadAll(r.Body)
+		if err != nil {
+			log.Println(err)
+			w.Write([]byte("Плохое тело запроса"))
+			return
+		}
+		// печатем тело запроса как строку
+		fmt.Println(string(bytesBody))
+		// отвечаем клиенту, что все хорошо
+		w.Write([]byte("OK!"))
+		return
+	}
+	w.Write([]byte("Разрешен только метод POST!"))
+}
+
+func server2() {
+	// Регистрируем обработчик для пути "/body"
+	http.HandleFunc("/body", handlerBody)
+	// Запускаем веи-сервер на порту 8080
+	err := http.ListenAndServe(":8080", nil)
+	if err != nil {
+		fmt.Println("Ошибка запуска сервера:", err)
+	}
+}
+
+// Коды ответа
+
+func handlerOK1(w http.ResponseWriter, r *http.Request) {
+	w.Write([]byte("Привет"))
+	w.WriteHeader(200)
+}
+
+func handlerOK2(w http.ResponseWriter, r *http.Request) {
+	if r.Method == "PUT" {
+		w.WriteHeader(http.StatusMethodNotAllowed) // return 405
+		return
+	}
+	w.Write([]byte("Привет!"))
+	w.WriteHeader(http.StatusOK)
+}
+
+func server3() {
+	http.HandleFunc("/", handlerOK1)
+	http.HandleFunc("2", handlerOK2)
+	err := http.ListenAndServe(":3000", nil)
+	if err != nil {
+		fmt.Println("Ошибка запуска сервера:", err)
+	}
+}

go/stepik/course_1/4/server_task.go

@@ -0,0 +1,73 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+)
+
+func main() {
+	// server1()
+	// server2()
+	server3()
+}
+
+func handlerHello(w http.ResponseWriter, r *http.Request) {
+	w.Write([]byte("Hello, web!"))
+}
+
+func server1() {
+	http.HandleFunc("/get", handlerHello)
+
+	err := http.ListenAndServe(":8080", nil)
+	if err != nil {
+		fmt.Println("Ошибка запуска сервера:", err)
+	}
+
+}
+
+func handlerName(w http.ResponseWriter, r *http.Request) {
+	w.Write([]byte("Hello," + r.URL.Query().Get("name")))
+}
+
+func server2() {
+	http.HandleFunc("/api/user", handlerName)
+
+	err := http.ListenAndServe(":9000", nil)
+	if err != nil {
+		fmt.Println("Ошибка запуска сервера:", err)
+	}
+}
+
+// Напиши веб сервер (порт :3333) - счетчик который будет обрабатывать
+// GET (/count) и POST (/count) запросы:
+// GET:  возвращает счетчик
+// POST: увеличивает ваш счетчик на значение  (с ключом "count")
+// которое вы получаете из формы, но если пришло НЕ число то нужно
+// ответить клиенту: "это не число" со статусом http.StatusBadRequest (400).
+
+var count int
+
+func handlerCount(w http.ResponseWriter, r *http.Request) {
+	if r.Method == "GET" {
+		fmt.Fprint(w, count)
+	} else if r.Method == "POST" {
+		cnt, err := strconv.Atoi(r.FormValue("count"))
+		if err != nil {
+			w.WriteHeader(http.StatusBadRequest) // return 400
+			w.Write([]byte("это не число"))
+			return
+		}
+		count += cnt
+	}
+	w.WriteHeader(http.StatusMethodNotAllowed) // return 405
+}
+
+func server3() {
+	http.HandleFunc("/count", handlerCount)
+
+	err := http.ListenAndServe(":3333", nil)
+	if err != nil {
+		fmt.Println("Ошибка запуска сервера:", err)
+	}
+}

go/stepik/course_1/4/timeout.go

@@ -0,0 +1,98 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"os"
+)
+
+func main() {
+	// httpExample()
+	httpExample2()
+	/*
+		// Подключаемся к серверу
+		conn, err := net.Deal("tcp", "localhost:4545")
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		defer conn.Close()
+
+		for {
+			var source string
+			// Запрашиваем у пользователя ввод
+			fmt.Print("Введите слово: ")
+			_, err := fmt.Scan(&source)
+			if err != nil {
+				fmt.Println("Некорректный ввод", err)
+				continue
+			}
+
+			// Отправляем сообщение
+			if n, err := conn.Write([]byte(source)); n == 0 || err != nil {
+				fmt.Println(err)
+				return
+			}
+
+			// Устанавливаем таймаут на чтение ответа
+			fmt.Println("Ответ:")
+			conn.SetReadDeadLine(time.Now().Add(time.Second * 5))
+
+			// Чтение данных в отдельном цикле
+			// Если сервер пришлет больше данных, они будут обработаны
+			for {
+				buff := make([]byte, 1024)
+				n, err := conn.Read(buff)
+				if err != nil {
+					break
+				}
+				fmt.Print(string(buff[0:n]))
+				// Сбрасываем таймаут до 700 миллисекунд после первых 1024 байт
+				conn.SetReadDeadLine(time.Now().Add(time.Millisecond))
+			}
+		}
+	*/
+}
+
+func httpExample() {
+	httpRequest := "GET / HTTP/1.1\n" +
+		"Host: go.dev\r\n" +
+		"Connection: close\r\n" +
+		"\r\n"
+	conn, err := net.Dial("tcp", "go.dev:80")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	defer conn.Close()
+
+	if _, err = conn.Write([]byte(httpRequest)); err != nil {
+		fmt.Println(err)
+		return
+	}
+
+	io.Copy(os.Stdout, conn)
+	fmt.Println("Done")
+}
+
+func httpExample2() {
+	// http запрос с методом GET
+	resp, err := http.Get("https://golang.org")
+	if err != nil {
+		log.Println(err)
+		return
+	}
+	// Закрываем телол ответа после работы с ним
+	defer resp.Body.Close()
+
+	data, err := io.ReadAll(resp.Body) // читаем ответ
+	if err != nil {
+		log.Println(err)
+		return
+	}
+
+	fmt.Printf("%s", data)
+}

go/stepik/course_1/4/udp/client/client.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"log"
+	"net"
+)
+
+func main() {
+	conn, err := net.DialUDP("udp", nil, &net.UDPAddr{IP: []byte{127, 0, 0, 1}, Port: 10001})
+	if err != nil {
+		log.Fatalln(err)
+	}
+	defer conn.Close()
+	message := "Привет!"
+	_, err = conn.Write([]byte(message))
+	if err != nil {
+		log.Println(err)
+	}
+}

go/stepik/course_1/4/udp/server/server.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net"
+)
+
+func main() {
+	serverConn, err := net.ListenUDP("udp", &net.UDPAddr{IP: []byte{0, 0, 0, 0}, Port: 10001})
+	if err != nil {
+		log.Fatalln(err)
+	}
+	defer serverConn.Close()
+	for {
+		buf := make([]byte, 1024)
+		n, _, err := serverConn.ReadFromUDP(buf)
+		if err != nil {
+			log.Println(err)
+		}
+		fmt.Println("Получено: ", string(buf[:n]))
+	}
+}

go/stepik/course_2/type/input_output.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+)
+
+func main() {
+	// foo1()
+	// bufio1()
+	// bestBook()
+	// repeat()
+	// splitter()
+	foo2()
+	// fmt.Println("#", 2)
+}
+
+func foo1() {
+	var s1, s2, s3 string
+
+	count, err := fmt.Scan(&s1, &s2, &s3)
+	fmt.Println(count, err)
+	fmt.Println(s1, s2, s3)
+
+}
+
+// bufio - пакет для буферизированного текстового ввода/вывода
+
+func bufio1() {
+	scanner := bufio.NewScanner(os.Stdin)
+	fmt.Println("Введите строку с пробелами:")
+	_ = scanner.Scan()     // ожидает ввод строки с клавиатуры до нажатия Enter
+	name := scanner.Text() // сохраняем введенную строку в переменную name
+	fmt.Println("Вы ввели:", name)
+}
+
+func bestBook() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	fmt.Println(scanner.Text() + " - лучшая книга!")
+}
+
+func repeat() {
+	var s1, s2, s3 string
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	s1 = scanner.Text()
+	scanner.Scan()
+	s2 = scanner.Text()
+	scanner.Scan()
+	s3 = scanner.Text()
+	fmt.Println(s1)
+	fmt.Println(s2)
+	fmt.Println(s3)
+}
+
+func splitter() {
+	scanner := bufio.NewScanner(os.Stdin)
+	scanner.Scan()
+	splitter := scanner.Text()
+	scanner.Scan()
+	s1 := scanner.Text()
+	scanner.Scan()
+	s2 := scanner.Text()
+	scanner.Scan()
+	s3 := scanner.Text()
+	fmt.Print(s1, splitter, s2, splitter, s3)
+}
+
+func foo2() {
+	var val int
+	fmt.Scan(&val)
+	prod := val
+	fmt.Scan(&val)
+	prod *= val
+	fmt.Scan(&val)
+	prod *= val
+
+	fmt.Println(prod)
+}

go/stepik/course_2/type/typess.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+)
+
+func main() {
+	// foo1()
+	sqr()
+}
+
+// нельзя складывать int с float
+func foo1() {
+	/*
+		var a int = 6
+		b := float64(a)
+		fmt.Println(b + 0.4)
+	*/
+
+	// var a int = 6
+	var a float64 = 6
+	fmt.Println(a + 0.4)
+
+	fmt.Println(3.6 / 1.5)
+}
+
+func sqr() {
+	var val int
+	fmt.Scan(&val)
+	fmt.Println(val * val)
+}