Go dla początkujących - Część 0: Porównanie Go i JavaScript

Witaj w zerowym artykule z naszego kursu Go dla początkujących! Dziś zmierzymy się z popularnym językiem JavaScript, aby pokazać Ci, jak Go wypada na jego tle w kontekście web developmentu. Przyjrzymy się kluczowym różnicom, od składni po zarządzanie pamięcią, i pokażemy, jak wykonywać te same zadania w obu językach. Gotowy na porównanie tytanów? Zaczynamy!

Wprowadzenie: Dwa różne światy, ten sam cel

Zarówno Go (Golang), jak i JavaScript, odgrywają znaczące role w świecie tworzenia aplikacji internetowych. JavaScript, król frontendu, dominuje w przeglądarkach, podczas gdy Go zyskuje popularność jako język backendowy, ceniony za wydajność i prostotę. Chociaż oba języki służą do budowania aplikacji webowych, ich podejścia są diametralnie różne.

Składnia: Prostota kontra elastyczność

Składnia Go jest inspirowana językiem C, charakteryzuje się prostotą i czytelnością. Jest zwięzła i konsekwentna, co ułatwia naukę i utrzymanie kodu. JavaScript, z kolei, jest bardziej elastyczny i dynamiczny, co czasami może prowadzić do niejasności.

Przykład: Deklaracja zmiennej

Go:

var name string = "Jan" // Jawna deklaracja typu
age := 30             // Krótka deklaracja (typ jest inferowany)

JavaScript:

var name = "Jan"; // Zmienna może zmieniać typ
let age = 30;     // Zmienna o zasięgu blokowym
const city = "Kraków"; // Stała

W Go typ zmiennej jest określony statycznie, co oznacza, że kompilator sprawdza typy już na etapie kompilacji. W JavaScript typ jest dynamiczny, co oznacza, że typ zmiennej może się zmieniać w trakcie działania programu.

Typy danych: Statyczna kontrola kontra dynamiczna elastyczność

Go jest językiem statycznie typowanym, co oznacza, że typy zmiennych są sprawdzane w czasie kompilacji. To pomaga wychwycić błędy na wczesnym etapie i zwiększa bezpieczeństwo kodu. JavaScript jest językiem dynamicznie typowanym, co daje większą elastyczność, ale może prowadzić do błędów trudnych do wykrycia.

Podstawowe typy danych:

• Go: int, float64, string, bool, array, slice, map, struct
• JavaScript: number, string, boolean, null, undefined, object, symbol

Przykład: Tablice

Go:

var numbers [5]int // Tablica o stałym rozmiarze
numbers[0] = 1
numbers := []int{1, 2, 3} // Slice (dynamiczna tablica)

JavaScript:

let numbers = [1, 2, 3]; // Tablica o zmiennym rozmiarze

W Go tablice mają stały rozmiar, natomiast slice są dynamiczne i bardziej elastyczne. W JavaScript tablice są zawsze dynamiczne.

Obsługa asynchroniczności: Goroutines kontra Promises

Go oferuje goroutines i channels do obsługi współbieżności. Goroutines to lekkie wątki, które pozwalają na jednoczesne wykonywanie wielu zadań. Channels służą do komunikacji między goroutines. JavaScript używa Promises i async/await do obsługi operacji asynchronicznych.

Przykład: Operacja asynchroniczna

Go:

package main

import (
        "fmt"
        "time"
)

func task(id int, c chan string) {
        time.Sleep(1 * time.Second)
        c <- fmt.Sprintf("Zadanie %d zakończone", id)
}

func main() {
        c := make(chan string)
        go task(1, c)
        msg := <-c
        fmt.Println(msg)
}

JavaScript:

function task(id) {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve(`Zadanie ${id} zakończone`);
    }, 1000);
  });
}

async function main() {
  const msg = await task(1);
  console.log(msg);
}

main();

Go radzi sobie z współbieżnością w sposób bardziej efektywny, zwłaszcza w aplikacjach o dużym obciążeniu.

Zarządzanie pamięcią: Garbage Collector kontra ręczne zarządzanie (brak w JS)

Go posiada automatyczny garbage collector (GC), który zwalnia nieużywaną pamięć. Programista nie musi się martwić ręcznym zarządzaniem pamięcią, co upraszcza pisanie kodu i zmniejsza ryzyko wycieków pamięci. JavaScript również korzysta z GC. W odróżnieniu od C/C++, ani Go, ani JavaScript nie oferują ręcznego zarządzania pamięcią.

Podstawowe operacje: Go w praktyce

Iteracja po tablicy (slice):

numbers := []int{1, 2, 3, 4, 5}
for i, number := range numbers {
    fmt.Println(i, number)
}

Obsługa stringów:

name := "Jan Kowalski"
fmt.Println(len(name))        // Długość stringa
fmt.Println(name[0:3])       // Wycięcie fragmentu stringa
fmt.Println(strings.ToUpper(name)) // Konwersja do dużych liter

Porównanie z JavaScript:

Iteracja po tablicy:

let numbers = [1, 2, 3, 4, 5];
numbers.forEach((number, index) => {
  console.log(index, number);
});

Obsługa stringów:

let name = "Jan Kowalski";
console.log(name.length);      // Długość stringa
console.log(name.substring(0, 3)); // Wycięcie fragmentu stringa
console.log(name.toUpperCase()); // Konwersja do dużych liter

Proste zadania: Przykłady kodu

Zadanie: Obliczenie sumy liczb w tablicy.

Go:

func sum(numbers []int) int {
    total := 0
    for _, number := range numbers {
        total += number
    }
    return total
}

JavaScript:

function sum(numbers) {
  let total = 0;
  for (let number of numbers) {
    total += number;
  }
  return total;
}

Praca domowa

1. Napisz program w Go, który odwraca kolejność znaków w podanym stringu.
2. Napisz program w JavaScript, który znajduje najdłuższe słowo w zdaniu.
3. Porównaj wydajność obu programów dla dużych danych (np. długie stringi, duże tablice).

Podsumowanie

Go i JavaScript to dwa różne podejścia do web developmentu. Go oferuje wydajność, prostotę i bezpieczeństwo typów, co czyni go idealnym wyborem dla backendu i aplikacji o wysokiej wydajności. JavaScript dominuje w frontendzie, oferując elastyczność i bogaty ekosystem. Wybór języka zależy od specyfiki projektu.

Zachęcamy do dalszego eksplorowania Go z naszym kursem! W kolejnych artykułach zgłębimy tajniki tworzenia aplikacji webowych w Go, od serwerów HTTP po bazy danych. Nie zapomnij eksperymentować z kodem i zadawać pytania! Powodzenia!