Hlavní navigace

Basic-256: další moderní reinkarnace BASICu určená pro výuku programování

19. 10. 2021
Doba čtení: 29 minut

Sdílet

 Autor: Depositphotos
Prozatím poslední moderní reinkarnací programovacího jazyka BASIC, s níž se seznámíme, je Basic-256. Opět se jedná o jazyk (a vývojové prostředí) určené primárně pro výuku programování, které navíc podporuje i práci s grafikou.

Obsah

1. Basic-256: další moderní reinkarnace BASICu určená pro výuku programování

2. Instalace Basicu-256

3. První seznámení s Basicem-256

4. Operace s proměnnými, aritmetické výrazy

5. Operace s řetězci

6. Vstupně-výstupní operace

7. Rozhodovací konstrukce if-then a její varianty

8. Rozhodovací konstrukce case

9. Počítaná programová smyčka typu for-next

10. Programové smyčky typu while a do-until

11. Předčasný výskok z programových smyček, skok na začátek další iterace

12. Výpočet největšího společného dělitele realizovaný v Basicu-256

13. Příkaz goto a návěští (labels)

14. Podprogramy realizované příkazy gosubreturn

15. Definice nových uživatelských funkcí

16. Definice a volání podprogramů (subrutin)

17. Základy práce s poli v Basicu-256

18. Popsané příkazy (klíčová slova) Basicu-256

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Basic-256: další moderní reinkarnace BASICu určená pro výuku programování

Již v předchozím článku jsme se zmínili o existenci několika moderních dialektů programovacího jazyka BASIC, které mnohdy nemají s původním BASICem (až na jméno) příliš společného. A právě takovým poměrně moderním dialektem BASICu je Basic-256 zmíněný v dnešním článku. Důvod, proč je zde tato aplikace zmíněna je jednoduchý – v Basicu-256 se velmi snadno pracuje s grafikou, což je samozřejmě pro potřeby výuky ideální (je například velmi snadné vytvořit si programovou pomůcku pro výuku matematiky či geometrie). Může se tak jednat o poměrně zajímavou alternativu k minule a předminule popsanému Small Basicu (a to i díky použité licenci). Paradoxně je Basic-256 v praxi mnohem lepším jazykem pro delší programy, než Small Basic, a to díky tomu, že podporuje rozdělení celého problému na podprogramy (subrutiny) a funkce.

Basic-256 ve skutečnosti není „pouze“ programovacím jazykem, ale jedná se o desktopovou aplikaci, která obsahuje i jednoduše použitelné a přehledné integrované vývojové prostředí, jež zahrnuje editor zdrojových kódů, okno zajišťující textový vstup a výstup (což znamená, že se jedná o formu textového terminálu), okno určené pro grafický vstup a výstup (grafickým vstupem je myšlena reakce na pohyb myši a stisk tlačítek myši) a v neposlední řadě podporuje toto integrované vývojové prostředí i krokování vytvářeného programu. Oproti dříve popsanému Small Basicu se však zapsaný zdrojový kód nekontroluje ihned při zápisu, ale až při jeho spuštění, popř. při krokování. To znamená, že reakce na případné chyby v zápisu zdrojového kódu jsou odhaleny později, než by to bylo pro začátečníky žádoucí. Chybová hlášení většinou obsahují přesné informace nejenom o řádku, na kterém je chyba, ale i o znaku, kde se nalezená chyba vyskytuje.

Obrázek 1: Přehledné integrované vývojové prostředí Basicu-256, které obsahuje jak podporu pro textový výstup, tak i okno, do kterého je možné vykreslit grafický výstup prováděný vytvářenou aplikací. Toto vývojové prostředí podporuje i krokování vyvíjeným programem.

2. Instalace Basicu-256

Na rozdíl od Microsoft Small Basicu je nutné Basic-256 nainstalovat. Instalační soubory pro Windows, popř. přímo spustitelná verze pro Windows, je dostupná přímo z úvodní stránky https://basic256.org/. V případě Linuxu je situace (většinou) ještě snazší, neboť Basic-256 je možné nainstalovat přímo z repositáře dané distribuce. Takže například:

$ sudo apt-get install basic256
 
Reading package lists... Done
Building dependency tree
Reading state information... Done
The following additional packages will be installed:
  espeak-data libespeak1 libportaudio2 libqt5multimedia5 libqt5printsupport5
  libqt5serialport5 libqt5sql5 libqt5sql5-sqlite
The following NEW packages will be installed:
  basic256 espeak-data libespeak1 libportaudio2 libqt5multimedia5
  libqt5printsupport5 libqt5serialport5 libqt5sql5 libqt5sql5-sqlite
0 upgraded, 9 newly installed, 0 to remove and 0 not upgraded.
Need to get 2 875 kB of archives.
After this operation, 16,7 MB of additional disk space will be used.
Do you want to continue? [Y/n]

Po instalaci by měl být dostupný příkaz basic256:

$ which basic256
 
/usr/bin/basic256

I (krátká) manuálová stránka:

$ man basic256
Poznámka: po spuštění vývojového prostředí Basicu-256 je vhodné si ověřit, jaká verze byla nainstalována. Mnoho Linuxových distribucí totiž obsahuje starší verze, v nichž některé příkazy nebudou plně funkční! Na rozdíly upozorním v dalším textu (není jich ovšem mnoho).

Obrázek 2: Ověření, která verze Basicu-256 byla nainstalována.

3. První seznámení s Basicem-256

Program typu „Hello, world!“ zapsaný v klasických BASICech pocházejících z osmdesátých let minulého století vypadá takto:

PRINT "Hello, world!"

V případě Basicu-256 je možné příkazy psát i malými písmeny, takže by tentýž program mohl vypadat následovně:

print "Hello, world!"

Komentáře lze zapisovat příkazem rem:

rem Ukázka komentářů v Basicu-256
rem Program typu "Hello, world!"
 
print "Hello, world!"

Nebo zkráceně pomocí znaku „#“:

# Ukázka komentářů v Basicu-256
# Program typu "Hello, world!"
 
print "Hello, world!"

V současnosti, kdy je prakticky každý osobní počítač současně i multimediální stanicí, by však měla moderní varianta programu typu „Hello, world!“ vypadat odlišně – počítač by tento pozdrav mohl říci. I to je v případě Basicu-256 možné, postačuje pouze namísto příkazu print zavolat funkci say:

say("Hello, world!")
Poznámka: tímto způsobem si současně ověříte, zda jsou nainstalovány i všechny potřebné podpůrné knihovny.

4. Operace s proměnnými, aritmetické výrazy

V Basicu-256 je možné pracovat s běžnými skalárními datovými typy, konkrétně s numerickými hodnotami (s plovoucí řádovou čárkou, podmnožinou jsou pak celá čísla) i s řetězci. Proměnné není zapotřebí deklarovat, protože se vytvoří automaticky při prvním přiřazení:

rem Základní práce s proměnnými
rem (numerické proměnné)
 
a = 42
print a
Poznámka: na rozdíl od mnoha klasických BASICů i od Small Basicu není možné pracovat s proměnnou, do které nebyla přiřazena hodnota. Naproti tomu Small Basic v takovém případě proměnnou vytvořil a současně i inicializoval na nulu – což je například v případě špatného opisu jména proměnné chyba neodhalená interpretrem.

Řetězcové proměnné musí končit znakem dolaru, čímž se Basic-256 v tomto ohledu přiblížil ke klasickým BASICům (a možná se pro začátečníky jedná o dobré řešení). Paměť pro řetězce se ovšem nemusí explicitně alokovat, což je u programovacího jazyku určeného pro začátečníky jen dobře:

rem Základní práce s proměnnými
rem (řetězcové proměnné)
 
a$ = "Hello, world!"
print a$

Pochopitelně je dodržena priorita základních aritmetických operátorů, což si lze ostatně snadno ověřit na následujícím demonstračním příkladu:

rem Aritmetické výrazy, priority základní operátorů
 
x = 10
y = 20
print (x + y) * 2
print x + (y * 2)
print x + y*2
Poznámka: kromě čtveřice základních aritmetických operátorů lze použít operátor \ pro celočíselné dělení, % pro dělení modulo, postfixové a prefixové operátory ++ a – a dokonce i všechny tři bitové operátory převzaté z céčka.

5. Operace s řetězci

Řetězce je možné snadno spojit operátorem + (který je tedy přetížený). Opět si povšimněte, že řetězce, resp. paměť pro řetězce není zapotřebí explicitně alokovat:

rem Operace s řetězci
rem Alokace a spojování řetězců
 
a$ = "Hello"
b$ = "world"
 
greeting$ = a$ + " " + b$ + "!"
print greeting$

Pro získání podřetězce se používají funkce nazvané left, right a mid, které byly (i když s dolarem na konci) zavedeny v Microsoft Basicu již před přibližně čtyřiceti lety:

rem Operace s řetězci
rem Získání podřetězců
 
a$ = "Hello, world!"
 
print left(a$, 5)
print right(a$, 6)
print mid(a$, 8, 5)
Poznámka: u funkce mid je nutné brát v úvahu, že první znak řetězce má index roven jedné! U ostatních dvou funkcí jsme od této „drobnosti“ zcela odstíněni.

Většina funkcí pro modifikaci řetězce ve skutečnosti vrací nový řetězec:

rem Operace s řetězci
rem Náhrada části řetězce za jiný řetězec
 
a$ = "Hello, world!"
 
print replace(a$, "world", "root.cz")

Konkrétně funkce replace ve výchozím nastavení nahrazuje všechny nalezené podřetězce, tedy odpovídá chováním spíše funkci replaceAll:

rem Operace s řetězci
rem Opakovaná náhrada části řetězce za jiný řetězec
 
a$ = "Hello, world!"
 
print replace(a$, "o", "*")

Velikosti písmen hrají v Basicu-256 roli pouze při práci s řetězci:

rem Operace s řetězci
rem Vliv velikosti znaků na operaci pro nahrazení
 
a$ = "Hello, world!"
 
print replace(a$, "O", "*")

Nahrazení lze ovšem provést bez ohledu na velikost písmen, a to použitím nepovinného čtvrtého parametru funkce replace:

rem Operace s řetězci
rem Vliv velikosti znaků na operaci pro nahrazení
 
a$ = "Hello, world!"
 
print replace(a$, "O", "*", true)
Poznámka: z tohoto demonstračního příkladu je patrné, že u již vytvořených funkcí je v některých případech podporován proměnný počet parametrů.

6. Vstupně-výstupní operace

Pro ruční zadávání číselných údajů nebo textu (řetězců) slouží v klasických verzích BASICu příkaz nazvaný INPUT. Ten ovšem například v minule zmíněném Small Basicu nenajdeme. Z tohoto pohledu se Basic-256 více přibližuje klasickým dialektům programovacího jazyka BASIC, protože příkaz INPUT (klidně i psaný malými písmeny) opět podporuje, jak je to ostatně patrné i z dalšího demonstračního příkladu:

rem Základní vstupně-výstupní operace
 
input "x = ", x
input "y = ", y
 
print "Result = ";
print x+y
Poznámka: v případě, že bude zadán nečíselný údaj, dosadí se do příslušné proměnné nulová hodnota!

Zajistit lze i vstup řetězců:

rem Základní vstupně-výstupní operace
 
input "jméno: ", name$
input "příjmení: ", surname$
 
print "Zadáno: " + name$ + " " + surname$

Základní výstupní operaci už známe – je zajištěna příkazem print, který dokáže vypsat jednu hodnotu či větší množství hodnot uspořádaných do sloupců. Tento příkaz lze zkrátit, ostatně podobně jako v klasických interpretrech BASICu, na jediný znak ? (tato možnost byla ovšem přidána až ve verzi 2.0).

Poznámka: kromě toho je do Basicu-256 plně integrován i grafický výstup, což je však téma, kterému se budeme věnovat až v navazujícím článku.

7. Rozhodovací konstrukce if-then a její varianty

Součástí prakticky jakéhokoli Turingovsky kompletního programovacího jazyka je nějaká forma rozhodovací konstrukce, popř. speciální formy se stejným významem. Výjimkou pochopitelně není ani dnes popisovaný Basic-256, který obsahuje strukturovaný příkaz typu if-then-else, jenž je doplněn o další užitečnou konstrukci case. Základní tvar tohoto příkazu neobsahuje větev else, skládá se tedy z klíčových slov if, then a endif:

rem Rozhodovací konstrukce if-then
rem Základní varianta s jedinou větví
 
print "x = "
input x
 
if x < 0 then
    print "Negative value"
endif

Takzvané úplné rozvětvení do dvou nezávislých větví se provede takto:

rem Rozhodovací konstrukce if-then
rem Rozšířená varianta s oběma větvemi
 
print "x = "
input x
 
if x < 0 then
    print "Negative value"
else
    print "Zero or positive value"
endif

Basicu-256 je možné – na rozdíl od mnoha starších dialektů programovacího jazyka BASIC – vnořit prakticky libovolné množství rozhodovacích konstrukcí if-then. Tuto možnost si ukážeme na demonstračním příkladu, který ve „vnější“ podmínce testuje, zda je zadaná hodnota záporná a pokud ne (tedy když je kladná či nulová), provede další rozvětvení. Mimochodem – díky tomu, že za klíčovým slovem then se automaticky vytvoří nový programový blok, by v tomto jazyku nemělo tak snadno dojít k chybám typu goto fail (k těm dochází u těch programovacích jazyků, kde je blok volitelný):

rem Rozhodovací konstrukce if-then
rem Vnořené příkazy if-then
 
print "x = "
input x
 
if x < 0 then
    print "Negative value"
else
    if x > 0 then
        print "Positive value"
    else
        print "Zero"
    endif
endif
Poznámka: jsou podporovány i jednořádkové konstrukce if-then-else, ovšem ty nejsou v praxi příliš přehledné.

8. Rozhodovací konstrukce case

Ve skutečnosti mnohdy potřebujeme vytvořit několik větví, každou vykonanou po splnění určité podmínky. Takové zřetězení podmínek v mnoha jiných programovacích jazycích zajišťuje konstrukce obsahující klíčové slovo elseif (psáno dohromady) nebo else if. Naproti tomu v Basicu-256 je podporována odlišná konstrukce založená na zápisu většího množství podmínek za klíčové slovo case. Výsledek je (podle mého názoru) čitelnější, protože opticky nepreferuje první podmínku tak, jako je tomu v řetězci if-elseif-elseif…:

rem Rozhodovací konstrukce case
 
print "x = "
input x
 
begin case
    case x < 0
        print "Negative value"
    case x > 0
        print "Positive value"
    else
        print "Zero"
endcase
Poznámka: poslední větev else odpovídá větvi default z podobné konstrukce switch-case známé z céčkovské větve programovacích jazyků (ovšem tato konstrukce je více omezená, než je tomu v případě Basicu-256).

9. Počítaná programová smyčka typu for-next

Prakticky všechny dialekty programovacího jazyka BASIC podporují počítanou programovou smyčku typu for-next. Určitou výjimkou byl minule popsaný Small Basic, v němž bylo klíčové slovo next nahrazeno za nicneříkající endfor bez specifikovaného kontextu (tedy jména řídicí proměnné smyčky). Basic-256 se v tomto ohledu vrací ke kořenům, což je ostatně patrné i na následujícím programu s počítanou smyčkou:

rem Základní podoba programové smyčky for-next
 
for i = 1 to 10
    print i
next i

Specifikovat je možné i krok, tedy hodnotu, o kterou se bude měnit počitadlo smyčky po každé iteraci:

rem Základní podoba programové smyčky for-next
rem se specifikací kroku
 
for i = 1 to 10 step 2
    print i
next i

V případě, že jsou oba limity nastaveny na shodnou hodnotu, proběhne tělo smyčky přesně jednou (na rozdíl od některých starších interpretrů, které se v tomto ohledu chovají chybně):

rem Základní podoba programové smyčky for-next
rem s oběma limitami nastavenými na shodnou hodnotu
 
for i = 0 to 0
    print i
next i

Již minule jsme si ukazovali příklad, ve kterém má dolní limit vyšší hodnotu než limit horní. Basic-256 na tuto situaci reaguje korektně, a to tak, že smyčka neproběhne ani jednou:

rem Základní podoba programové smyčky for-next
rem s dolním limitem vyšším než horní limit
 
for i = 1 to 0
    print i
next i

Na rozdíl od (například) Pascalu je možné v BASICech měnit hodnotu počitadla o neceločíselný krok:

rem Základní podoba programové smyčky for-next
rem se záporným krokem.
 
for i = 1 to 0 step -0.3
    print i
next i

Následující demonstrační příklad ukazuje jeden z problematických rysů Basicu-256: i když lze limity počítané programové smyčky specifikovat proměnnou, nebude případná změna této proměnné uvnitř smyčky reflektována, což je chování odlišné od Small Basicu. To mj. znamená, že zdaleka ne všechny algoritmy jsou jednoduše přenositelné na sémantické úrovni (syntaxe odlišná je, ale je snadné ji upravit):

rem Programová smyčka for-next
rem s postupně modifikovaným horním limitem
 
max = 5
for i = 1 to max
    print i
    max = max + 2
next i

Totéž platí i při snaze modifikovat hodnotu kroku – opět nebude nová hodnota korektně reflektována:

rem Programová smyčka for-next
rem s postupně modifikovaným krokem
 
s = 1
for i = 1 to 10 step s
    print i
    s = s / 2.0
next i

10. Programové smyčky typu while a do-until

Dalším typem programové smyčky je smyčka typu while. Ta například v GW-BASICu existuje ve variantě založené na klíčových slovech WHILE a WEND. V Basicu-256 je začátek smyčky (a podmínka) zapsána za klíčovým slovem while a konec smyčky je označen souslovím end while:

rem Základní podoba programové smyčky typu while
 
i = 1
 
while i < 1000
    print i
    i = i * 2
end while

Existuje i programová smyčka, v níž se podmínka pro ukončení testuje až po provedení těla smyčky. V Basicu-256 je tato smyčka reprezentována klíčovými slovy do a until:

rem Základní podoba programové smyčky typu do-until
 
i = 1
 
do
    print i
    i = i * 2
until i > 1000
Poznámka: tyto smyčky lze pochopitelně různým způsobem vnořovat. Praktické příklady si ukážeme příště.

11. Předčasný výskok z programových smyček, skok na začátek další iterace

Předčasný výskok z programové smyčky typu for-next se provádí příkazem exit for, který tedy odpovídá příkazu break z céčkovské větve programovacích jazyků:

for i = 1 to 100
    print i
    if i > 17 then
        exit for
    endif
next i

Podobným způsobem je možné vyskočit i z dalších typů programových smyček.

Existuje i příkaz typu continue, který provede okamžitý přeskok na podmínky určující, zda se má provést další iterace či nikoli:

for i = 1 to 20
    if i % 2 = 0 then
        continue for
    endif
    print i
next i

Varianta příkazu continue pro další typy programových smyček:

i = 0
 
while i <= 20
    i = i + 1
    if i % 2 = 0 then
        continue while
    endif
    print i
end while

A konečně varianta continue, tentokrát pro smyčku do-until:

i = 0
 
do
    i = i + 1
    if i % 2 = 0 then
        continue do
    endif
    print i
until i >= 20

12. Výpočet největšího společného dělitele realizovaný v Basicu-256

V článcích o GW-BASICu (PC-Basicu) i o Small Basicu jsme si ukázali program pro výpočet největšího společného dělitele dvou celých kladných čísel. Tento výpočet je možné s využitím programové smyčky typu while realizovat i v Basicu-256, a to například následujícím způsobem:

rem Výpočet největšího společného dělitele
 
print "x = "
input x
 
print "y = "
input y
 
while x<>y
    if x>y then
        x=x-y
    endif
    if x<y then
        y=y-x
    endif
end while
 
print "gcd = "
print x
Poznámka: lze použít i kratší verzi programu, v níž jsou podmínky zapsány na jediném řádku a celé tělo programové smyčky se tak zmenší na pouhé dva řádky. To je ovšem na úkor čitelnosti.

13. Příkaz goto a návěští (labels)

Basic-256 by nebyl pravým BASICem, kdyby neobsahoval příkaz GOTO. Ovšem vzhledem k tomu, že se v tomto dialektu BASICu nepoužívají čísla řádků, je nutné cíl skoku definovat takzvaným návěštím neboli label. V naprosté většině algoritmů se příkazu goto snadno vyhneme, ovšem pro úplnost si ukažme příklad jeho použití:

i = 1
 
LOOP:
    print i
    i = i + 1
    if i <= 10 then
        goto LOOP
    endif

Přepis algoritmu pro výpočet největšího společného dělitele lze přepsat nestrukturovaným způsobem tak, aby se použil právě příkaz goto:

rem *****************************
rem Výpočet největšího společného
rem dělitele.
rem
rem Úprava pro Basic-256
rem
rem *****************************
rem
rem
 
print "X = "
input x
 
print "Y = "
input y
 
LOOP:
if x = y then
    print x
    goto DONE
endif
 
if x > y then
    x = x -y
    goto LOOP
endif
 
if x < y then
    y = y -x
    goto LOOP
endif
 
DONE:

Je však nutné si dát pozor na to, aby jméno návěští nebylo shodné s nějakým klíčovým slovem (což je jedna z největších nevýhod těchto moderních BASICů – mají příliš velké množství klíčových slov, do kterých se lze relativně snadno „trefit“):

rem *****************************
rem Výpočet největšího společného
rem dělitele.
rem
rem Úprava pro Basic-256
rem
rem Nekorektní název cíle skoku
rem *****************************
rem
rem
 
print "X = "
input x
 
print "Y = "
input y
 
LOOP:
if x = y then
    print x
    goto END
endif
 
if x > y then
    x = x -y
    goto LOOP
endif
 
if x < y then
    y = y -x
    goto LOOP
endif
 
END:

14. Podprogramy realizované příkazy gosubreturn

Basic-256 pochopitelně podporuje tvorbu podprogramů, podobně jako prakticky všechny starší implementace BASICu. Připomeňme si, že v klasických nestrukturovaných BASICech nebyl začátek podprogramu nijak označen – prostě se jednalo o jakýkoli programový řádek, na který se skákalo příkazem GOSUB (podprogram tedy ani nebyl pojmenován). Návrat z podprogramu byl řešen příkazem RETURN. V případě Basicu-256 lze tento postup stále použít, ovšem namísto čísla řádku se pochopitelně použije návěští. Alternativně lze ovšem deklarovat i plnohodnotné funkce a podprogramy, což si ukážeme v navazujících kapitolách. Nejdříve se však podívejme na jednoduchý demonstrační příklad, v němž jsou použita klíčová slova gosub a return:

rem *****************************
rem Výpočet faktoriálu
rem
rem Úprava pro Basic-256
rem
rem Použití programové konstrukce
rem GOSUB-RETURN
rem
rem *****************************
 
for n=1 to 20
    gosub FACTORIAL
    print fact
next n
end
 
rem *****************************
rem Výpočet faktoriálu
rem *****************************
 
FACTORIAL:
    fact=1
    for i=n to 1 step -1
        fact=fact*i
    next i
    return 

15. Definice nových uživatelských funkcí

Mnohem silnější programovací technikou je ovšem definice nových uživatelských funkcí. Díky podpoře uživatelských funkcí je možné celý problém rozdělit na jednodušeji implementovatelné a testovatelné jednotky – a právě tvorba programů stylem „rozděl a panuj“ by se měla učit již v prvních nepatrně složitějších algoritmech. Podívejme se nyní na to, jak lze funkce použít v Basicu-256:

rem *****************************
rem Výpočet faktoriálu
rem
rem Úprava pro Basic-256
rem
rem Použití definované uživatelské
rem funkce
rem
rem *****************************
 
for n=1 to 20
    print factorial(n)
next n
end
 
rem *****************************
rem Výpočet faktoriálu
rem *****************************
 
function factorial(n)
    fact=1
    for i=n to 1 step -1
        fact=fact*i
    next i
    return fact
end function

Vidíme, že pro návrat hodnoty z funkce je použito klíčové slovo return. Alternativně je však možné použít zápis, který více odpovídá původním „strukturovaným“ BASICům, tedy přiřazením návratové hodnoty do jména funkce:

rem *****************************
rem Výpočet faktoriálu
rem
rem Úprava pro Basic-256
rem
rem Použití definované uživatelské
rem funkce
rem
rem *****************************
 
for n=1 to 20
    print factorial(n)
next n
end 
 
rem *****************************
rem Výpočet faktoriálu
rem *****************************
 
function factorial(n)
    fact=1
    for i=n to 1 step -1
        fact=fact*i
    next i
    factorial = fact
end function

16. Definice a volání podprogramů (subrutin)

Basic-256 podporuje i tvorbu plnohodnotných (pojmenovaných) podprogramů, a to dokonce podprogramů s parametry. Nesmíme však zapomenout na to, že volání podprogramů je realizováno klíčovým slovem call, tedy odlišným způsobem, než volání funkcí:

rem *****************************
rem Výpočet faktoriálu
rem
rem Úprava pro Basic-256
rem
rem Použití podprogramu.
rem
rem *****************************
 
for n=1 to 20
    call factorial(n)
next n
end
 
rem *****************************
rem Výpočet faktoriálu
rem *****************************
 
subroutine factorial(n)
    fact=1
    for i=n to 1 step -1
        fact=fact*i
    next i
    print fact
end subroutine

17. Základy práce s poli v Basicu-256

Vyzkoušejme si ještě práci s poli. Pole je – na rozdíl od řetězců – nutné alokovat, a to příkazem dim. Délku pole lze získat zcela unikátně – výrazem jméno_pole[?]:

rem Alokace pole a výpis délky pole
 
dim a(10)
 
print a[?]

Prvky pole lze procházet standardní počítanou smyčkou for-next:

rem Procházení prvky pole
rem S využitím standardní smyčky FOR-NEXT
 
dim a(10)
 
for i = 0 to a[?]-1
    a[i] = 1/(i+1)
next i
 
for i = 0 to a[?]-1
    print a[i]
next i

Nebo je možné použít specializovanou smyčku for-each:

rem Procházení prvky pole
rem S využitím smyčky FOR-EACH
 
dim a(10)
 
for i = 0 to a[?]-1
    a[i] = 1/(i+1)
next i
 
for each item in a
    print item
next item
Poznámka: ve skutečnosti podporuje Basic-256 i práci s mapami, což si ukážeme příště.

18. Popsané příkazy (klíčová slova) Basicu-256

Jak je u různých dialektů programovacího jazyka BASIC zvykem, je struktura programů určována do velké míry použitými klíčovými slovy (neboli příkazy) a nikoli množstvím různých dalších znaků.

Linux tip

V dnešním článku jsme si popsali následující příkazy:

# Příkaz Stručný popis příkazu
1 print tisk hodnoty na textovou konzoli
2 say hlasité přečtení obsahu řetězce
3 rem poznámka (lze nahradit znakem #)
4 input interaktivní vstup (číslo nebo řetězec)
5 if příkaz, za kterým následuje podmínka
6 then začátek větve vykonané při splnění podmínky
7 endif konec rozhodovacího příkazu if
8 else začátek větve vykonané při nesplnění podmínky
9 begin case začátek rozhodovací konstrukce s více podmínkami
10 case začátek větve se specifikovanou podmínkou
11 endcase konec rozhodovacího příkazu case
12 for začátek počítané programové smyčky
13 to klíčové slovo, za nímž následuje horní mez smyčky
14 step klíčové slovo, za nímž následuje krok smyčky
15 next konec počítané programové smyčky
16 while začátek programové smyčky s testem na začátku
17 end while konec programové smyčky s testem na začátku
18 do začátek programové smyčky s testem na konci
19 until konec programové smyčky s testem na konci
20 goto nestrukturovaný skok na určené návěští (label)
21 gosub skok do podprogramu realizovaný návěštím
22 return návrat z podprogramu
23 function začátek definice funkce
24 end function konec definice funkce
25 subroutine začátek definice podprogramu
26 end subroutine konec definice podprogramu
27 call volání podprogramu
28 dim alokace pole
29 end ukončení celého programu

19. Repositář s demonstračními příklady

Všechny dnes popsané demonstrační příklady určené pro Basic-256 (a tudíž nekompatibilní s žádným jiným BASICem) byly uloženy do Git repositáře, který je dostupný na adrese https://github.com/tisnik/8bit-fame. Tyto příklady si můžete v případě potřeby stáhnout i jednotlivě bez nutnosti klonovat celý (dnes již poměrně rozsáhlý) repositář:

# Příklad Stručný popis příkladu Adresa
1 01_hello_world.bas program typu „Hello, world!“ v Basicu-256 https://github.com/tisnik/8bit-fame/blob/master/Basic-256/01_hello_world.bas
2 02_comment.bas zápis komentářů https://github.com/tisnik/8bit-fame/blob/master/Basic-256/02_comment.bas
3 03_int_variable.bas práce s celočíselnými proměnnými https://github.com/tisnik/8bit-fame/blob/master/Basic-256/03_int_variable.bas
4 04_string_variable.bas práce s řetězcovými proměnnými https://github.com/tisnik/8bit-fame/blob/master/Basic-256/04_string_variable.bas
5 05_expressions.bas základní aritmetické výrazy, priorita operátorů https://github.com/tisnik/8bit-fame/blob/master/Basic-256/05_expressions.bas
6 06_string_concatenation.bas operace spojení řetězců https://github.com/tisnik/8bit-fame/blob/master/Basic-256/06_string_concatenation.bas
7 07_substring.bas získání podřetězce https://github.com/tisnik/8bit-fame/blob/master/Basic-256/07_substring.bas
8 08_string_replace.bas náhrada části řetězce jiným řetězcem https://github.com/tisnik/8bit-fame/blob/master/Basic-256/08_string_replace.bas
9 09_string_replace.bas vícenásobná náhrada podřetězce https://github.com/tisnik/8bit-fame/blob/master/Basic-256/09_string_replace.bas
10 10_string_replace.bas vliv velikosti znaků při nahrazování https://github.com/tisnik/8bit-fame/blob/master/Basic-256/10_string_replace.bas
11 11_string_replace.bas vliv velikosti znaků při nahrazování https://github.com/tisnik/8bit-fame/blob/master/Basic-256/11_string_replace.bas
12 12_input_output.bas základní vstupně-výstupní operace https://github.com/tisnik/8bit-fame/blob/master/Basic-256/12_input_output.bas
13 13_if_then.bas rozhodovací konstrukce typu if-then (jedna větev) https://github.com/tisnik/8bit-fame/blob/master/Basic-256/13_if_then.bas
14 14_if_then_else.bas rozhodovací konstrukce typu if-then-else (obě větve) https://github.com/tisnik/8bit-fame/blob/master/Basic-256/14_if_then_else.bas
15 15_nested_ifs.bas vnořené rozhodovací konstrukce typu if-then-else https://github.com/tisnik/8bit-fame/blob/master/Basic-256/15_nested_ifs.bas
16 16_case.bas rozhodovací konstrukce typu case https://github.com/tisnik/8bit-fame/blob/master/Basic-256/16_case.bas
17 17_for_next.bas počítaná programová smyčka typu for-next https://github.com/tisnik/8bit-fame/blob/master/Basic-256/17_for_next.bas
18 18_for_next_step.bas počítaná programová smyčka typu for-next s počitadlem https://github.com/tisnik/8bit-fame/blob/master/Basic-256/18_for_next_step.bas
19 19_for_next_same_limits.bas oba shodné limity v programové smyčce for-next https://github.com/tisnik/8bit-fame/blob/master/Basic-256/19_for_next_same_limits.bas
20 20_for_next_illegal.bas dolní limit větší než horní limit https://github.com/tisnik/8bit-fame/blob/master/Basic-256/20_for_next_illegal.bas
21 21_for_next_count_down.bas počítání směrem dolů https://github.com/tisnik/8bit-fame/blob/master/Basic-256/21_for_next_count_down.bas
22 22_for_next_variable_max.bas postupná modifikace horního limitu ve smyčce for-next https://github.com/tisnik/8bit-fame/blob/master/Basic-256/22_for_next_variable_max.bas
23 23_for_next_variable_step.bas postupná modifikace kroku ve smyčce for-next https://github.com/tisnik/8bit-fame/blob/master/Basic-256/23_for_next_variable_step.bas
24 24_while.bas programová smyčka typu while https://github.com/tisnik/8bit-fame/blob/master/Basic-256/24_while.bas
25 25_do_until.bas programová smyčka typu do-until https://github.com/tisnik/8bit-fame/blob/master/Basic-256/25_do_until.bas
26 26_exit_for.bas předčasný výskok ze smyčky for-next https://github.com/tisnik/8bit-fame/blob/master/Basic-256/26_exit_for.bas
27 27_continue_for.bas příkaz continue for https://github.com/tisnik/8bit-fame/blob/master/Basic-256/27_continue_for.bas
28 28_continue_while.bas příkaz continue while https://github.com/tisnik/8bit-fame/blob/master/Basic-256/28_continue_while.bas
29 29_continue_do.bas příkaz continue do https://github.com/tisnik/8bit-fame/blob/master/Basic-256/29_continue_do.bas
30 30_gcd.bas výpočet největšího společného dělitele https://github.com/tisnik/8bit-fame/blob/master/Basic-256/30_gcd.bas
31 31_goto.bas nestrukturovaný příkaz goto https://github.com/tisnik/8bit-fame/blob/master/Basic-256/31_goto.bas
32 32_goto_GCD.bas využití příkazu goto při výpočtu největšího společného dělitele https://github.com/tisnik/8bit-fame/blob/master/Basic-256/32_goto_GCD.bas
33 33_goto_GCD_error.bas problematické použití klíčového slova v jiném kontextu https://github.com/tisnik/8bit-fame/blob/master/Basic-256/33_goto_GCD_error.bas
34 34_factorial.bas výpočet faktoriálu, konstrukce gosubreturn https://github.com/tisnik/8bit-fame/blob/master/Basic-256/34_factorial.bas
35 35_factorial_function.bas definice funkce pro výpočet faktoriálu https://github.com/tisnik/8bit-fame/blob/master/Basic-256/35_factorial_function.bas
36 36_factorial_function.bas definice funkce pro výpočet faktoriálu, alternativní výstup z funkce https://github.com/tisnik/8bit-fame/blob/master/Basic-256/36_factorial_function.bas
37 37_factorial_subroutine.bas definice podprogramu pro výpočet faktoriálu https://github.com/tisnik/8bit-fame/blob/master/Basic-256/37_factorial_subroutine.bas
38 38_arrays.bas alokace pole a výpis délky pole https://github.com/tisnik/8bit-fame/blob/master/Basic-256/38_arrays.bas
39 39_arrays.bas procházení prvky pole standardní smyčkou for-next https://github.com/tisnik/8bit-fame/blob/master/Basic-256/39_arrays.bas
40 40_arrays.bas procházení prvky pole konstrukcí for-each https://github.com/tisnik/8bit-fame/blob/master/Basic-256/40_arrays.bas

20. Odkazy na Internetu

  1. Stránka projektu Basic-256
    https://basic256.org/
  2. So You Want to Learn to Program – BASIC-256 (Third Edition)
    http://syw2l.org/?page_id=407
  3. Why Another BASIC?
    https://basic256.org/2019/06/27/why-another-basic/
  4. Stránka projektu Small Basic
    https://smallbasic-publicwebsite.azurewebsites.net/
  5. List of Programs Made with Small Basic
    https://social.technet.mi­crosoft.com/wiki/contents/ar­ticles/14013.list-of-programs-made-with-small-basic.aspx
  6. Expert to Expert: The Basics of SmallBasic
    https://channel9.msdn.com/blog­s/charles/expert-to-expert-the-basics-of-smallbasic
  7. The Developer’s Reference Guide to Small Basic
    https://social.technet.mi­crosoft.com/wiki/contents/ar­ticles/16767.the-developers-reference-guide-to-small-basic.aspx
  8. Small Basic – Talking to Raspberry Pi
    https://techcommunity.micro­soft.com/t5/small-basic-blog/small-basic-talking-to-raspberry-pi/ba-p/337844
  9. Small Basic – Arduino
    https://techcommunity.micro­soft.com/t5/small-basic-blog/small-basic-arduino/ba-p/337762
  10. Small Basic + micro:bit
    https://techcommunity.micro­soft.com/t5/small-basic-blog/small-basic-micro-bit/ba-p/1968424
  11. #1 Learn Small Basic Programming – Introduction
    https://www.youtube.com/wat­ch?v=e_BaEPCa8OQ
  12. #2 Learn Small Basic Programming – Input, Output & Variables
    https://www.youtube.com/wat­ch?v=VWekYLa33OI
  13. #3 Learn Small Basic Programming – String Concatenation
    https://www.youtube.com/wat­ch?v=iWvIaOaT474
  14. Small Basic – The Programmer's Guide
    https://www.i-programmer.info/programming/other-languages/5196-small-basic-the-programmers-guide.html
  15. Rosetta Code: Category:Microsoft Small Basic
    https://rosettacode.org/wi­ki/Category:Microsoft_Sma­ll_Basic
  16. Fifty Years of BASIC, the Programming Language That Made Computers Personal
    https://time.com/69316/basic/
  17. BBC BASIC i QBasic oslavují svá kulatá výročí
    https://www.root.cz/clanky/bbc-basic-i-qbasic-oslavuji-sva-kulata-vyroci/
  18. What are the best BASIC-like programming languages?
    https://www.slant.co/topic­s/9807/~basic-like-programming-languages
  19. List of BASIC dialects
    https://en.wikipedia.org/wi­ki/List_of_BASIC_dialects
  20. GW-BASIC Documentation
    https://hwiegman.home.xs4a­ll.nl/gwbasic.html
  21. Microsoft Open-Sources GW-BASIC
    https://devblogs.microsof­t.com/commandline/microsoft-open-sources-gw-basic/
  22. GW-BASIC na GitHubu
    https://github.com/microsoft/GW-BASIC
  23. Welcome to GW-BASIC
    http://www.antonis.de/qbe­books/gwbasman/
  24. GWBASIC User's Manual
    http://www.antonis.de/qbe­books/gwbasman/index2.html
  25. The basics of BASIC, the programming language of the 1980s
    https://www.youtube.com/wat­ch?v=seM9SqTsRG4
  26. GW-BASIC User's Guide
    https://hwiegman.home.xs4all.nl/gw-man/index.html
  27. PC-BASIC 1.2.14 documentation
    http://robhagemans.github­.io/pcbasic/doc/1.2/
  28. PEEK and POKE
    https://en.wikipedia.org/wi­ki/PEEK_and_POKE
  29. GW-BASIC | DRAW Statement (video na Youtube)
    https://www.youtube.com/wat­ch?v=4I1CELY13M4
  30. Rozdíly mezi GW-BASIC a QBasicem
    https://hwiegman.home.xs4a­ll.nl/extern/Differences%20Bet­ween%20GW-BASIC%20and%20QBasic.htm
  31. GW-Basic Programs
    https://gwbasicprograms.blog­spot.com/p/gw-basic-programs.html
  32. GW-BASIC Resource
    https://gw-basic.netlify.app/
  33. A page about GWBASIC Games & Other Programs
    http://peyre.x10.mx/GWBASIC/
  34. Basic BASIC, 2nd Edition, James S. Coan
    https://drive.google.com/uc?ex­port=download&id=1Z12L7SO_gfNg3Ma_0­eH2_Kz15YM-9dHl
  35. Advanced BASIC, James S. Coan
    https://drive.google.com/uc?ex­port=download&id=1JafSpV_BLyl­WHMd16rDPorwv9wV9bLcy
  36. Structured BASIC, 2nd Edition, James F. Clark (naskenovaná kniha)
    https://drive.google.com/uc?ex­port=download&id=1pT8y-8yJYS_SqvxF0fBHm6S-dlAt-Uy2
  37. Last Book of GW-Basic
    https://www.geocities.ws/jo­seph_sixpack/btoc.html
  38. SCIENTIFIC PROGRAMS WRITTEN IN BASIC (for PCs)
    https://web.archive.org/web/20160323064356/htt­p://www.scn.org/~bh162/ba­sic_programs.html
  39. Why I love programming on FreeDOS with GW-BASIC
    https://opensource.com/ar­ticle/21/6/freedos-gw-basic
  40. Quite BASIC (web-based classic BASIC online programming environmen)
    http://www.quitebasic.com/
  41. GFA-BASIC
    http://sites.google.com/si­te/gfabasic16/
  42. E-mail od tvůrce GW-Basicu
    http://www.classiccmp.org/pi­permail/cctech/2005-April/042999.html
  43. General Electric GE-400
    http://www.feb-patrimoine.com/PROJET/ge400/ge-400.htm
  44. GE-400 Time-sharing information systems:
    http://www.computerhistory­.org/collections/accession/102646147
  45. A brief history of the development of BASIC (pravděpodobně již nefunkční odkaz)
    http://www.phys.uu.nl/~ber­gmann/history.html
  46. History of BASIC (PDF)
    http://www.q7basic.org/His­tory%20of%20BASIC.pdf
  47. Dartmouth College Computation Center. 1964.-The original Dartmouth BASIC manual
    http://www.bitsavers.org/pdf/dar­tmouth/BASIC_Oct64.pdf
  48. The Original BASIC
    http://www.truebasic.com/
  49. BASIC – Beginners All-purpose Symbolic Instruction Code
    http://hopl.murdoch.edu.au­/showlanguage.prx?exp=176
  50. Dartmouth Time Sharing System
    http://en.wikipedia.org/wi­ki/Dartmouth_Time_Sharing_Sys­tem
  51. General Electric (Wikipedia)
    http://en.wikipedia.org/wi­ki/General_Electric
  52. GE 225 vs. IBM 1401
    http://ed-thelen.org/GE225-IBM1401.html
  53. A GE-225 is found
    http://ed-thelen.org/comp-hist/GE225.html
  54. G.E. 200 Series Computers
    http://www.smecc.org/g_e__200_se­ries_computers.htm
  55. DTSS – Dartmouth Time Sharing System
    http://dtss.dartmouth.edu/index.php
  56. John G. Kemeny: BASIC and DTSS: Everyone a Programmer
    http://dtss.dartmouth.edu/e­veryoneaprogrammer.php
  57. GE-200 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-200_series
  58. GE-400 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-400_series
  59. GE-600 series (Wikipedia)
    http://en.wikipedia.org/wiki/GE-600_series
  60. ZX Basic Manual
    http://www.worldofspectrum­.org/ZXBasicManual/
  61. ZX81 BASIC Programming
    http://www.worldofspectrum­.org/ZX81BasicProgramming/
  62. Sinclair BASIC History
    http://scratchpad.wikia.com/wi­ki/Sinclair_BASIC_History
  63. Sinclair BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Sinclair_BASIC
  64. Sinclair BASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/Sinclair_BASIC
  65. Beta BASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/Beta_BASIC
  66. Beta BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Beta_BASIC
  67. BETA BASIC NEWSLETTER No 8
    http://spectrum128.ru/hel­p/BetaBasicNewsletter8.pdf
  68. R. T. RUSSELL: The home of BBC BASIC
    http://www.rtrussell.co.uk/
  69. R. T. RUSSELL: A History of BBC BASIC
    http://www.cix.co.uk/~rrus­sell/bbcbasic/history.html
  70. SuperBASIC (Wikipedia EN)
    http://en.wikipedia.org/wi­ki/SuperBASIC
  71. SuperBASIC (Wikipedia CZ)
    http://en.wikipedia.org/wi­ki/SuperBASIC
  72. Laser Basic/Laser Compiler
    http://www.sincuser.f9.co­.uk/049/laser.htm
  73. Laser BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Laser_BASIC
  74. BBC BASIC
    http://www.bbcbasic.co.uk/bbcba­sic.html
  75. BBC BASIC
    http://mdfs.net/Software/BBCBasic/
  76. BBC BASIC (Z80) for the ZX Spectrum
    http://mdfs.net/Software/BBCBa­sic/Spectrum/
  77. BBC BASIC (Wikipedia CZ)
    http://en.wikipedia.org/wi­ki/BBC_BASIC
  78. BeebWiki – 8-bit Acorn Computer Wiky
    http://beebwiki.jonripley­.com/Main_Page
  79. Porovnání osmibitů
    http://porovnani8bitu.spa­ces.live.com/
  80. Rosetta Code – Main Page
    http://rosettacode.org/wiki/Main_Page
  81. Rosetta Code – Category Basic
    http://rosettacode.org/wi­ki/Category:BASIC
  82. QBasicJedi
    http://www.freewebs.com/qbasicjedi/
  83. QBasic/QuickBasic Downloads
    http://www.freewebs.com/qba­sicjedi/qbdownloads.html
  84. QuickBASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/QuickBASIC
  85. QBasic.com
    http://www.qbasic.com/
  86. QBasic (Wikipedia)
    http://cs.wikipedia.org/wiki/QBasic
  87. Dialling with QBASIC
    http://www.mysundial.ca/tsp/qba­sic.html
  88. BASIC (Wikipedia EN)
    http://en.wikipedia.org/wiki/BASIC
  89. BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wiki/BASIC
  90. Turbo BASIC (Wikipedia CZ)
    http://cs.wikipedia.org/wi­ki/Turbo_BASIC
  91. More BASIC Computer Games
    http://www.atariarchives.or­g/morebasicgames/
  92. How to build an interpreter in Java, Part 1: The BASICs
    http://www.javaworld.com/jw-05–1997/jw-05-indepth.html
  93. INTEGER BASIC Reference
    http://www.landsnail.com/a2ref2.htm
  94. APPLESOFT Reference
    http://www.landsnail.com/a2ref.htm
  95. Applesoft Lite: Applesoft BASIC for the Replica-1
    http://cowgod.org/replica1/applesoft/
  96. Simons' BASIC
    http://en.wikipedia.org/wi­ki/Simons'_BASIC
  97. Simon's Basic
    http://www.lemon64.com/?ma­inurl=http%3A//www.lemon64­.com/museum/list.php%3Fli­neoffset%3D54%26genre%3Dma­nualmisc
  98. BASIC
    http://www.c64-wiki.com/index.php/BASIC
  99. C64 Wiki: Simons Basic
    http://www.c64-wiki.de/index.php/Simons_Basic
  100. Simons' Basic (evaluation)
    http://www.atarimagazines­.com/creative/v9n11/60_Si­mons_Basic.php
  101. Bill Gates' Personal Easter Eggs in 8 Bit BASIChttp://www.pagetable.com/?p=43
  102. Třicet let od vydání revolučního Turbo Pascalu 5.5
    https://www.root.cz/clanky/tricet-let-od-vydani-revolucniho-turbo-pascalu-5–5/
  103. Let's make a small and simple GW-BASIC program!
    https://www.youtube.com/wat­ch?v=OyPUn74nj-s
  104. Seriál Letní škola programovacího jazyka Logo
    http://www.root.cz/serialy/letni-skola-programovaciho-jazyka-logo/
  105. Educational programming language
    http://en.wikipedia.org/wi­ki/Educational_programmin­g_language
  106. Logo Tree Project:
    http://www.elica.net/downlo­ad/papers/LogoTreeProject­.pdf

Autor článku

Pavel Tišnovský vystudoval VUT FIT a v současné době pracuje ve společnosti Red Hat, kde vyvíjí nástroje pro OpenShift.io.