Готовы погрузиться в захватывающий мир программирования на Go? Не смотрите дальше, потому что этот блог создан для того, чтобы сделать ваше путешествие максимально легким и приятным! Go, также известный как Golang, — это язык программирования, который покорил мир технологий своей простотой, скоростью и параллелизмом. И угадай что? Научиться Го проще, чем вы думаете!
Как человек, изучавший Go во время стажировки, я понимаю, что онлайн-курсы могут занимать много времени. Так что, если вы хотите изучить основы Go и у вас мало времени (как у меня), этот блог поможет вам!
Привет, мир на Голанге
Начнем с кода, без которого введение ни в один язык программирования не кажется полным, классического «Hello, World!» программа. Код на Golang очень лаконичен и легко читается. Вот как написать простую программу на Golang:
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
Предложение пакета запускает каждый исходный файл и указывает, что файл принадлежит указанному пакету. Вторая строка import "fmt" импортирует пакет fmt, который предоставляет функции для форматирования и печати текста (например, файл заголовка stdio.h в C++). Скоро мы узнаем больше о пакетах и импорте.
Функция main является точкой входа в программу. Он выполняется при запуске программы. Когда компилятор Go создает программу, он ищет основной пакет и, в частности, основную функцию в этом пакете. Если основная функция не найдена, программа не запустится.
Переменные
В Golang переменные объявляются с помощью ключевого слова var, за которым следует имя переменной и ее тип. Вот пример:
var x int = 10
Вы также можете объявить несколько переменных одновременно:
var x, y int = 10, 20
В дополнение к ключевому слову var вы также можете использовать сокращенный оператор := для объявления и инициализации переменной:
x := 10
Функции
Функции в Golang определяются с помощью ключевого слова func, за которым следует имя функции, параметры и тип возвращаемого значения. Вот пример:
package main
import "fmt"
func main() {
var sum int=add(10,2);
fmt.Println("Sum of 10 and 2 is: ",sum)
}
func add(x int, y int) int {
return x + y
}
Вы также можете иметь несколько возвращаемых значений:
func swap(x, y string) (string, string) {
return y, x
}
Пакеты и импорт в Go
В Go нет концепции ООП, как в C++ и Python. Но у Go есть пакеты, с помощью пакетов мы можем определить имя каталога, в котором находятся все исходные файлы Go, относящиеся к этому пакету.
Например: если у нас есть пакет с именем «myutil», который предоставляет некоторые служебные функции, мы можем создать под ним три файла:
myutil/ ├── stringutil.go └── mathutil.go └── funcutil.go main.go
myutil — это каталог (и имя пакета), в котором находятся три файла, а main.go — это файл вне каталога. В каждом из этих файлов мы можем определить код, который нам нужен. mathutil.go может иметь такую структуру кода:
package myutil
// Add returns the sum of two integers.
func Add(a, b int) int {
return a + b
}
// Subtract returns the difference of two integers.
func Subtract(a, b int) int {
return a - b
}
Обратите внимание, что имя пакета остается myutil. И мы можем использовать эти функции в файлах другой программы Go, импортируяmyutil пакет.
Пример того, как использовать эти функции вне каталога myutil:
package main
import (
"fmt"
"myutil"
)
func main() {
fmt.Println(myutil.Add(2, 3))
fmt.Println(myutil.Subtract(5, 2))
}
Здесь мы импортируем пакет fmt для печати на консоль и пакет myutil для использования служебных функций, которые мы определили ранее. Мы вызываем функции Add и Subtract из mathutil.go, используя следующий синтаксис:
myutil.<function name>(arguments)
Структуры управления
Golang поддерживает все обычные структуры управления.
если еще
Операторы if, if-else и if-else if используются для проверки условий. Мы указываем условие, и если это условие выполняется, этот блок будет выполнен.
package main
import "fmt"
func main() {
var num int = 10
if num < 0 {
fmt.Println("The number is negative")
} else if num > 0 && num < 10 {
fmt.Println("The number is between 1 and 9")
} else {
fmt.Println("The number is greater than or equal to 10")
}
}
Петли
В Golang есть только один тип цикла — цикл for. Циклы используются для многократного выполнения блока кода. Базовый синтаксис цикла for в Go включает ключевое слово for, условие и блок кода, который необходимо выполнить. Go также поддерживает цикл for на основе диапазона, который перебирает элементы массива, среза, строки или карты.
package main
import "fmt"
func main() {
// Simple for loop
fmt.Println("Counting from 0 to 9")
for i:=0; i<10; i++{
fmt.Println(i)
}
// Another way (similar to a while loop in C++)
j:=0
for j<10{
fmt.Println(j)
j++
}
}
Прервать и продолжить
break используется, когда мы хотим выйти из цикла при выполнении определенного условия. Продолжить используется, когда мы хотим пропустить цикл для этой конкретной итерации.
package main
import "fmt"
func main() {
var i int = 10
for i < 20 {
fmt.Printf("value of i: %d\\\\n", i);
i++;
if i > 15 {
break;
}
}
fmt.Println("After break, Odd numbers from 0 to 9: ")
for i:=0; i<10; i++{
if i%2==0{
continue
}
fmt.Println(i)
}
}
Выключатель
Операторы switch можно использовать в любое время, когда вам нужно обработать несколько случаев значения кратким и удобочитаемым способом. Они могут быть хорошей альтернативой длинным цепочкам операторов if и else if.
package main
import "fmt"
func main() {
var num int = 2
switch num {
case 1:
fmt.Println("The number is one")
case 2:
fmt.Println("The number is two")
case 3:
fmt.Println("The number is three")
default:
fmt.Println("The number is not one, two or three")
}
}
Оператор switch проверяет num по каждому из случаев, и, если он соответствует случаю, выполняется соответствующий блок кода. В этом случае вывод будет «Число равно два».
Если ни один из вариантов не соответствует, выполняется блок кода по умолчанию. В этом случае вывод будет «Число не один, два или три».
Множество
Массивы — это структуры данных фиксированной длины, которые хранят данные одного типа в смежных ячейках памяти. Синтаксис: var <array_name> [<array_size>]<data_type>
package main
import "fmt"
func main() {
var arr [4] int
arr[0]=1
arr[1]=2
arr[2]=3
for i:=0; i<len(arr); i++{
fmt.Println(arr[i])
}
}
Функция len возвращает длину массива. Обратите внимание, что arr[4] не был инициализирован, поэтому было напечатано значение по умолчанию 0.
Массивы также можно инициализировать с помощью следующих сокращенных обозначений:
arr:= []int {1,2,3,4}
\\OR
var arr[4]int = [4]int{1, 2, 3, 4}
Эти обозначения проще в использовании и более читабельны.
Обратите внимание, что вы не можете изменить длину массива, поэтому вам нужно знать длину заранее. Но что если вы не знаете длину и все равно хотите хранить элементы? Для этого можно использовать ломтики.
Кусочек
В Go срез — это динамическая структура данных, обеспечивающая гибкий способ работы с коллекциями данных. Срез похож на массив, но он может динамически увеличиваться или уменьшаться во время выполнения, в отличие от массива, размер которого фиксирован.
Вы можете объявить срез, используя любой из следующих двух методов:
var numbers[]int
numbers := []int{1, 2, 3, 4}
Одной из ключевых особенностей срезов является их способность динамически увеличиваться или уменьшаться в размере. Вы можете добавлять элементы в слайс, используя функцию append. Вы также можете получить доступ к отдельным элементам среза с помощью индексации, как и в случае с массивом.
package main
import "fmt"
func main() {
slice := []int{1, 2, 3, 4}
fmt.Println(slice)
slice = append(slice, 5, 6, 7, 8)
fmt.Println(slice)
fmt.Println(slice[3])
}
карта
Карта — это встроенная структура данных, позволяющая хранить пары ключ-значение. Карты используются для представления коллекций связанных данных, где каждый элемент идентифицируется уникальным ключом.
package main
import "fmt"
func main() {
m := make(map[string]int)
m["apple"] = 1
m["orange"] = 2
m["banana"] = 3
fmt.Println(m)
fmt.Println(m["apple"])
fmt.Println(m["mango"])
delete(m,"apple")
fmt.Println(m)
}
Результат будет:
map[apple:1 banana:3 orange:2] 1 0 map[banana:3 orange:2]
Структура
В Go структура — это определяемый пользователем тип данных, который объединяет ноль или более переменных разных типов в единый модуль. Вы можете использовать структуру для определения ваших собственных пользовательских типов данных и представления сложных объектов в вашей программе.
package main
import "fmt"
type Person struct {
Name string
Age int
Address string
}
func main() {
var p1 Person // one way to create a new instance of Person
p1.Name = "Akanksha"
p1.Age = 30
p1.Address = "12, XYZ Apartment"
p2 := Person{Name: "Bunty", Age: 25, Address: "Block 56, ABC street"} // another way to create a new instance of Person
fmt.Println(p1.Name) // prints "Akanksha"
fmt.Println(p2.Age) // prints 25
}
указатели
Указатель — это переменная, в которой хранится адрес памяти другой переменной. Указатели часто используются для более эффективного управления и передачи данных в программе.
Хорошо, я знаю, что указатели — не самая популярная тема среди новичков, но они очень важны, особенно в Go, с точки зрения параллелизма, потому что они позволяют более эффективно обмениваться данными и манипулировать ими между горутинами.
Чтобы инициализировать переменную-указатель, вы можете использовать оператор адреса (&), который возвращает адрес памяти переменной:
var i int = 10 p = &i
Чтобы разыменовать переменную-указатель и получить доступ к значению, на которое она указывает, вы можете использовать оператор разыменования (*):
fmt.Println(*p) // prints 10
Вы также можете передавать указатели в качестве аргументов функций. Вот пример:
package main
import "fmt"
func increment(p *int) {
*p++
}
func main() {
i:= 10
increment(&i)
fmt.Println(i) // prints 11
}
Заключение
Это лишь некоторые из основ Golang. Golang становится все более популярным благодаря своей простоте и эффективности. Если вы хотите изучить новый язык программирования, Golang определенно стоит рассмотреть.
Я не рассматривал тестирование и параллелизм здесь, может быть, в каком-то следующем блоге. Пожалуйста, не стесняйтесь оставлять свои предложения в комментариях!
