Ebben a cikkben a progromozás alapjait fogjuk átnézéni, egyszerű példákon keresztül.

Mi a program?

A program egy olyan utasítássorozat amit a számítógép végre tud hajtani. A számítógépnek két része van, ami most fontos nekünk. A processzor (CPU) és a memória (RAM).

Processzor: Van egy utasítás készlete. Amikor a gép futtatja a programot, akkor a processzor sorban végig megy az utasítássorozaton ami a programban van és végrehajtja. Ilyen utasítások lehetnek pl.: összeadás, kivonás, adat mozgatás és még sok másik.

Memória: Egy tároló, ami kis részekre van felosztva és minden résznek van egy száma (cím). A processzor a memóriában lévő adatokkal tud műveleteket végezni.

Példa egy konkrét programra: “c7 45 f4 0a 00 00 00 c7 45 f8 02 00 00 00 c7 45 fc 00 00 00 00 8b 55 f4 8b 45 f8 01 d0 89 45 fc”. Ez az utasítássorozat kiszámolja mennyi 10+2 és tárolja az eredmenyt a memóriában.

Mi a programnyelv?

Ha alaposan megfigyeljük az előbbi programot, észrevehetjük hogy, ha igy kellene programozni, nem sok programozó lenne.

A programnyelvek olyan programok, amikben könnyebben érthető módon tudjuk leírni a programunkat és az alapján a programnyelv létre hozza a megfelelő gépi utasításokat. Rengeteg féle programnyelv van.

Pythonban például így néz ki:

a = 10
b = 2
eredmeny = a+b

(A Python program nem pontosan ugyan azokat a gépi utasításokat fogja végrehajtani)

A Go programnyelv

A Go a Google által fejlesztett programnyelv. Arra tervezték hogy:

A Go Playground-on egyszerűen le lehet futtatni a példa kódokat, de érdemes telepíteni a gépre.

A Go nyelvről részletesebben a Learning Go könyvből érdemes tanulni.

Az első programkódunk

Feladat: írassuk ki a programmal hogy “Hello World”! 

1
2
3
4
5

package main
import "fmt"
func main() {
    fmt.Println("Hello World")
}

Ha sikerült lefuttatni, nézzük meg, mi mit jelent:

package main import "fmt" func main() { fmt.Println("Hello World") }
Ez a kód a main csomagba kerül, szükségünk lesz az fmt csomagra, a program azt az utasítást tartalmazza hogy írd ki: Hello World.

Változók

A változókat úgy képzelhetjük el mint dobozokat, amikbe dolgokat tudunk tenni, azzal a megkötéssel hogy ha valamit beleteszünk a dobozba, akkor ami előtte benne volt, megsemmisül.

Technikailag a váltzók, eszközök a programnyelvekben, amin keresztül a memóriát használhatjuk, így nem közvetlenül memóriacímekkel kell dolgoznunk.

Ahhoz hogy használni tudjuk a változókat, 3 fontos dolgokat kell tudnunk:

Feladat: írjunk programot, ami kiírja mennyi 10+2, változók használatával (hasonlóan mint a gépi kód fentebb)!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package main

import "fmt"

func main() {
    var a, b, sum int

    a = 10
    b = 2
    sum = a + b

    fmt.Println(sum)
}

A kiemelt sorok magyarázata:

var a, b, sum int a = 10 b = 2 sum = a + b
Foglalj le helyet a memóriában 3 változónak a, b, sum néven amikben egész számokat lehet tárolni.
Az a változóhoz tartozó memóriarészt állítsd be 10-re .
Az b változóhoz tartozó memóriarészt állítsd be 2-re.
Foglalj le helyet egy átmeneti változónak, az értéke legyen a + b.
A sum változóhoz tartozó memóriarészt állítsd be az átmenti változó értékére.

Mire szoktuk használni a változókat?

A változók szerepéről az eredeti tanulmány.

Ciklus (ismételt végrehajtás)

Az előbbi listában sokszor szerepelt a “lista feldolgozása”. Amikor egy listát dolgozunk fel, akkor egy kódrészletet akarunk lefuttatni annyiszor, amennyi elem van a listában. Vagy addig akarunk ismételni egy kód részletet amig nem végzett a program. Ezekre és a hasonló feladatokra ciklust használunk.

Feladat: írjunk programot, ami összeadja a számokat 1-től 10-ig!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package main
import "fmt"
func main() {
	var sum int
	for i := 1; i <= 10; i++ {
		sum += i
	}

	fmt.Println("Az összeg: ", sum)
}

A kiemelt sorok magyarázata (nagy kép):

var sum int for i := 1; i <= 10; i++ { sum += i }
Új változó sum néven (gyűjtő) amiben egész számokat fogunk tárolni Ismételd tízszer a következő utasítást (ciklusmag): sum változóhoz add hozzá az i változót

A “i := 1; i <= 10; i++” részletesebben:

i := 1; i <= 10; i++
Mielőtt a ciklus elindul, hozz létre egy i változót (léptető) és állítsd be 1-re az értékét Ha az i kisebb egyenlő mint 10 hajtsd végre a ciklus magját A ciklus ciklusmag végrehajtása után növeld az i-t 1-el

Tehát a ciklus végrehajtása így fog kinézni:

i := 1 (az i értéke: 1) i <= 10 sum += i (az i értéke: 1) i++ i <= 10 sum += i (az i értéke: 2) i++ i <= 10 sum += i (az i értéke: 3) i++ i <= 10 sum += i (az i értéke: 4) i++ i <= 10 sum += i (az i értéke: 5) i++ i <= 10 sum += i (az i értéke: 6) i++ i <= 10 sum += i (az i értéke: 7) i++ i <= 10 sum += i (az i értéke: 8) i++ i <= 10 sum += i (az i értéke: 9) i++ i <= 10 sum += i (az i értéke: 10) i++ i <= 10 (az i értéke: 11) Itt véget ér a ciklus mert az i <= 10 már nem igaz

Kérdés: mennyi lesz a sum változó értéke?

Elágazás (feltételes végrehajtás)

A ciklusoknál láttuk hogy a számítógép képes, bizonyos feltételek esetén különböző utasításokat végrehajtani. Ez a programkódban közvetlenül nem jelent meg, de amikor az i <= 10 feltétel igaz, akkor olyan utasítást hajt végre a processzor, hogy a ciklusmag elején keresse a következő utasítást, amikor hamis, akkor pedig a ciklusmag vége után.

Bármilyen utasításnál meg lehet oldani, hogy bizonyos feltételek esetén fusson csak le. Pl.: ha az óra 9-et mutat azt írjuk ki hogy “Jó napot!”, ha többet, akkor azt hogy “Mikor lesz már vége a napnak?”.

Feladat: írjunk programot, ami kiírja hogy nyár van-e. Ha 6. 7. vagy 8. hónapban vagyunk akkor nyár van, különben nincs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main
import (
	"fmt"
	"time"
)

func main() {
	month := time.Now().Month()
	if month >= 6 && month < 9 {
		fmt.Println("Nyár van")
	} else {
		fmt.Println("Nincs nyár")
	}
}

A kiemelt sorok magyarázata:

month := time.Now().Month() if month >= 6 && month < 9 { fmt.Println("Nyár van") } else { fmt.Println("Nincs nyár") }
Új változó month ami legyen az aktuális hónap száma (1..12) ha az aktuális hónap 6 és 9 között van ird ki: "Nyár van" különben ird ki: "Nincs nyár"