Avocado - Dokumentacja

Pobierz Avocado

Pobierz Avocado dla systemu Windows Pobierz

Instalacja Avocado

W nowej wersj Avocado v 1.0.1.0 kompilator FPC jest dołączony, wystarczy rozpakować najnowszą wersję Avocado z rozszerzeniem .7z i można pisać kod

Pobrać kompilator FPC możesz na SourceForge SourceForge lub na oficjalnej stronie FPC

W ustawieniach IDE na platformie Windows należy dodać ścieżkę do kompilatora fpc.exe, np.:

C:\Users\Programista Art\Downloads\fpc\3.2.2\bin\x86_64-win64\fpc.exe

W ustawieniach IDE na platformie Windows należy dodać ścieżkę W „Link do folderu FPC:, np.:

C:\Users\Programista Art\Downloads\fpc\3.2.2\

Typy Całkowite (Integer) (9)🔢

Nazwa polska	Nazwa angielska	Opis
`liczba_całkowita` lub `lc`	`int`	Liczba całkowita ze znakiem o rozmiarze zależnym od platformy (zazwyczaj 4 bajty, np. -2147483648 do 2147483647) – zalecany typ domyślny.
`liczba_mała`	`int16`	Liczba całkowita ze znakiem o rozmiarze 2 bajtów (-32768 do 32767).
`liczba_długa`	`int32`	Liczba całkowita ze znakiem o rozmiarze 4 bajtów (-2147483648 do 2147483647).
`liczba_krótka`	`int8`	Liczba całkowita ze znakiem o rozmiarze 1 bajta (-128 do 127)
`liczba64`	`int64`	Liczba całkowita ze znakiem o rozmiarze 8 bajtów (-9223372036854775808 do 9223372036854775807).
`bajt`	`byte`	Liczba całkowita bez znaku o rozmiarze 1 bajta (0 do 255).
`liczba16`	`uint16`	Liczba całkowita bez znaku o rozmiarze 2 bajtów (0 do 65535) – liczba dodatnia, 16-bitowa.
`liczba32`	`uint32`	Liczba całkowita bez znaku o rozmiarze 4 bajtów (0 do 4294967295) – liczba dodatnia, 32-bitowa.
`qliczba`	`qword`	nie ma znaku, możesz przechowywać duże wartości binarne, adresy, maski bitowe, ID, znaczniki czasu, itp. potrzebujesz dużych liczb całkowitych (większych niż LongWord), liczby nie mogą być ujemne, chcesz operować na adresach, wskaźnikach lub surowych danych pamięci, implementujesz coś niskopoziomowego (np. VM, JIT, system liczenia cykli procesora, itp.).

Typy Rzeczywiste (Zmiennoprzecinkowe - Real) (6) 📊

Nazwa polska	Nazwa angielska	Opis
`liczba_zm` lub `lzm`	`real`	Typ zmiennoprzecinkowy o rozmiarze zależnym od implementacji (zazwyczaj odpowiada Double) – niezalecany do nowych projektów.
`liczba_pojedyncza`	`ubyte`	Liczba zmiennoprzecinkowa o pojedynczej precyzji (4 bajty).
`liczba_podwójna`	`float`	Liczba zmiennoprzecinkowa o podwójnej precyzji (8 bajtów) – zalecany typ domyślny.
`liczba_rozszerzona`	`float80`	Liczba zmiennoprzecinkowa o rozszerzonej precyzji (10 bajtów).
`liczba_zgodna_delphi`	`comp`	Liczba całkowita o rozmiarze 8 bajtów, przechowywana jako zmiennoprzecinkowa (dla kompatybilności z Delphi).
`liczba_waluta`	`decimal`	Typ danych do operacji finansowych, o stałej precyzji (8 bajtów).

Typy Logiczne (Boolean) ✅

Nazwa polska	Nazwa angielska	Opis
`logiczny`	`bool`	Przyjmuje wartości `prawda` lub `fałsz` (zazwyczaj 1 bajt).
`logiczny_bajt`	`byte_bool`	Liczba – 0 oznacza fałsz, każda inna wartość to prawda (1 bajt).
`logiczne_słowo`	`--`	Podobny do logiczny_bajt, ale o rozmiarze 2 bajtów.
`logiczny_długi`	`long_bool`	Podobny do logiczny_bajt, ale o rozmiarze 4 bajtów.

Typy Znakowe (Char) (2)

Nazwa polska	Nazwa angielska	Opis
`znak`	`char`	Pojedynczy znak (zazwyczaj 1 bajt, reprezentujący znak ASCII).
`znak_unicode`	`char32`	Pojedynczy znak Unicode (zazwyczaj) `2` lub `4` bajty, zależnie od implementacji).

Typy Łańcuchowe (String) (6)

Nazwa polska	Nazwa angielska	Opis
`tekst`	`string`	Łańcuch znaków o dynamicznej długości – tzw. długi łańcuch.
`tekst255`	`string255`	Łańcuch o statycznej długości (maks. 255 znaków), z pierwszym bajtem przechowującym długość.
`tekst_ansi`	`ansi_string`	Alias dla `tekst.`
`tekst_unicode`	`unicode_string`	Łańcuch Unicode o dynamicznej długości, zalecany do obsługi znaków spoza standardowego zestawu.
`tekst_systemowy`	`wide_string`	Łańcuch Unicode, podobny do UnicodeString, lecz zarządzany przez system.
`lista_tekstów`	`string_list`	Łańcuch Unicode, podobny do UnicodeString, lecz zarządzany przez system.

Typy Tablicowe (Array) (3)

Nazwa polska	Nazwa angielska	Opis
`tablicaLiczb nazwa = [1,2,3,4]`	`--`	Tablica liczbowa o stałym rozmiarze.
`tablicaTekstów nazwa = [’a’,’b’,’c’]`	`--`	Tablica tekstowa o stałym rozmiarze
`ustaw_długość(tablica, 10)`	`set_length(tablica, 10)`	Ustawienie rozmiaru tablicy tekstów i tablicy liczb

Typy Zbiorowe (Set) (1)

Nazwa polska	Nazwa angielska	Opis
`kolekcja`	`set`	Zbiór unikalnych elementów określonego typu (typ bazowy musi być prosty, np. Znak lub typ wyliczeniowy).

Typy Plikowe (File) (4)

Nazwa polska	Nazwa angielska	Opis
`plik`	`file`	Ogólny typ plikowy.
`plik_tekstowy`	`text_file`	Plik tekstowy.
`plik_binarny`	`binary_file`	Plik binarny.
`plik_struktur`	`file_struct`	Plik zawierający rekordy określonego typu.

Typy Wskaźnikowe (Pointer) (2)

Nazwa polska	Nazwa angielska	Opis
`wskaźnik`	`pointer`	Ogólny typ wskaźnikowy, przechowujący adres pamięci.
`wskaźnik_na`	`pointer_to`	Wskaźnik do zmiennej określonego typu.

Typy Wariantowe (Variant) (2)

Nazwa polska	Nazwa angielska	Opis
`wariant`	`any`	Zmienna mogąca przechowywać dane różnych typów – używać ostrożnie (brak kontroli typu może prowadzić do błędów).
`oleVariant`	`ole_variant`	Wariant kompatybilny z technologią OLE (Object Linking and Embedding).

Konwersje (46)

Nazwa polska poprzednia	Nazwa polska nowa od V 1.0.1.0	Nazwa angielska	Opis
`TekstWLiczbac()`	`tekst_na_liczbę()`	`str_int()`	Konwertuje tekst na liczbę całkowitą.
`BajtWTekst()`	`bajt_na_logiczny()`	`byte_bool()`	rzutowanie
`TekstWLiczbar()`	`tekst_na_zmiennoprzecinkową()`	`str_float()`	Konwertuje tekst na liczbę zmiennoprzecinkową.
`LiczbacWTekst()`	`liczba_na_tekst()`	`int_str`	Konwertuje liczbę całkowitą na tekst.
`LiczbarWTekst()`	`zmiennoprzecinkowa_na_tekst()`	`float_str()`	Konwertuje liczbę zmiennoprzecinkową na tekst.
`LiczbacWr()`	`rzeczywista()`	`real()`	Konwertuje liczbę całkowitą na liczbę zmiennoprzecinkową.
`LiczbarWc()`	`obetnij()`	`trunc()`	Konwertuje liczbę zmiennoprzecinkową na liczbę całkowitą.
`LogicznyWTekst()`	`logiczny_na_tekst()`	`bool_str()`	Konwertuje wartość logiczną na tekst.
`TekstLD(tekst,wartość_domyślna)`	`tekst_na_liczbę_lub_domyślną(tekst,wartość_domyślna)`	`str_int_def(tekst,wartość_domyślna)`	Konwertuje string na liczbę całkowitą. Jeśli konwersja się nie powiedzie, zwraca wartość_domyślna.
`Zaokrąglij(liczba_zmiennoprzecinkowa)`	`zaokrąglij(liczba_zmiennoprzecinkowa)`	`round(liczba_zmiennoprzecinkowa)`	Zaokrągla liczbę zmiennoprzecinkową do najbliższej liczby całkowitej.
`Słowo(większa_liczba_całkowita)`	`na_całkowitą_16(większa_liczba_całkowita)`	`word(większa_liczba_całkowita))`	Rzutowanie
`Liczba_dc(większa_liczba_całkowita)`	`liczba_całkowita_32(większa_liczba_całkowita)`	`long_int(większa_liczba_całkowita)`	Rzutowanie
`Kard(liczba_całkowita)`	`liczebnik(liczba_całkowita)`	`cardinal(int)`	Rzutowanie. Zapewnia konwersję na typ bez znaku.
`FormatLiczby(liczba_zmiennoprzecinkowa, format, precyzja, cyfry)`	`zmiennoprzecinkowa_na_tekst_formatowany`	`float_strf(liczba_zmiennoprzecinkowa, format, precyzja, cyfry)`	Konwertuje liczbę zmiennoprzecinkową na string z kontrolowanym formatowaniem. format to jedna z wartości ffGeneral, ffExponent, ffFixed, ffNumber, ffCurrency. precyzja i cyfry kontrolują liczbę cyfr.
`TekstWLiczbar()`	`tekst_na_zmiennoprzecinkową()`	`str_float()`	Konwertuje string na liczbę zmiennoprzecinkową.
`LiczbarWR(Liczba_rozszerzona)`	`podwójna_precyzja()`	`double(float80)`	Rzutowanie między typami zmiennoprzecinkowymi.
`Liczba_pojedynczaWZm(liczba_podwójna/Liczba_rozszerzona)`	`Liczba_pojedyncza_na_zm(liczba_podwójna/Liczba_rozszerzona)`	`single(float80)`	Rzutowanie
`Liczba_rozszerzonaWPojedynczą(Liczba_pojedyncza/liczba_podwójna)`	`liczba_rozszerzona_na_pojedyńczą(Liczba_pojedyncza/liczba_podwójna)`	`extended(ubyte/float)`	Rzutowanie
`ZnakwASCII(kod_ASCII)`	`liczba_na_znak(kod_ASCII)`	`chr(kod_ASCI)`	Konwertuje kod ASCII (liczba całkowita) na znak.
`ord(znak)`	`znak_na_liczbę(znak)`	`ord(char)`	Konwertuje znak na jego kod ASCII (liczbę całkowitą).
`TekstWZnak(Znak)`	`tekst_na_znak(znak)`	`string(char)`	Tworzy jednoznakowy Tekst z podanego znaku
`ZnakWTekst(tekst[indeks])`	`znak_na_tekst(tekst[indeks])`	`char(string[index])`	Pobiera znak z tekstu na danej pozycji (indeksowanie od 1). Nie jest to konwersja, ale często używany sposób dostępu do pojedynczego znaku w tekście.
`LogicznyWTekst(logiczny, użyj wartości prawda lub falsz)`	`logiczny_na_tekst(logiczny, użyj wartości prawda lub falsz)`	`bool_str(bool, użyj wartości true lub false)`	Konwertuje wartość logiczną (Logiczny) na Tekst. Jeśli używasz wartości Prawda lub Falsz jest Prawda, używa `Prawda` i `Falsz`; jeśli Falsz (domyślnie), używa "1" i "0".
`TekstWLogiczny(tekst)`	`tekst_na_logiczny(tekst)`	`str_bool(string)`	Konwertuje string ("prawda", "falsz", "1", "0") na wartość logiczną. Wielkość liter nie ma znaczenia przy "prawda" i "falsz". Zwraca błąd w przypadku nieprawidłowego tekstu.
`TekstWLogicznyDom(tekst, wartość domyślna)`	`tekst_na_logiczny_dom(tekst, wartość domyślna)`	`str_bool_def(string, wartość domyślna)`	Konwertuje string na wartość logiczną. Jeśli konwersja się nie powiedzie, zwraca wartość domyślną.
`LogicznyZliczby(liczba):`	`logiczny_z_liczby(liczba)`	`bool(liczba)`	Rzutowanie. 0 jest konwertowane na Falsz, każda inna wartość na Prawda.
`LiczbacZLogicznego(Logiczny)`	`liczba_całkowita_z_logicznego(Logiczny)`	`int(bool)`	Rzutowanie. `prawda / true` jest konwertowane na 1, `falsz / false` na 0.
`LiczbacZWyliczenia(wartość wyliczeniowa)`	`liczba_całkowita_z_wyliczenia(wartość wyliczeniowa)`	`ord(wartość wyliczeniowa)`	Zwraca numer porządkowy wartości wyliczeniowej (liczbę całkowitą).
`ZwróćNazwęTekst(TypWyliczeniowy, Liczba(wartość wyliczeniowa))`	`pobierz_nazwę_tekstu(TypWyliczeniowy, Liczba(wartość wyliczeniowa))`	`get_enum_name(TypWyliczeniowy, Liczba(wartość wyliczeniowa))`	Zwraca nazwę wartości wyliczeniowej jako string. Wymaga modułu TypInfo.
`ZwróćLiczbac(TypWyliczeniowy, Nazwa Wartości):`	`pobierz_wartość_wyliczenia(TypWyliczeniowy, Nazwa Wartości)`	`get_enum_value(TypWyliczeniowy, Nazwa Wartości)`	Zwraca wartość wyliczeniową (jako Liczbę całkowitą) na podstawie nazwy (Tekst). Wymaga modułu TypInfo.
`DataWTekst(data)`	`data_na_tekst(data)`	`date_str(data)`	Konwertuje datę na tekst w domyślnym formacie.
`CzasWTekst(czas)`	`czas_na_tekst(czas)`	`time_str(czas)`	Konwertuje czas na tekst w domyślnym formacie.
`DataCzasWTekst(data i czas)`	`data_czas_na_tekst(data i czas)`	`date_time_str(data i czas)`	Konwertuje datę i czas na tekst w domyślnym formacie.
`DataCzasWTekstF(format, data i czas)`	`formatuj_data_czas_na_tekst(format, data i czas)`	`format_date_time(format, data i czas)`	Konwertuje datę i czas na tekst z użyciem podanego formatu. format to string, który zawiera specyfikatory formatowania (np. "yyyy-mm-dd hh:nn:ss").
`TekstWCzas(tekst)`	`tekst_na_czas(tekst)`	`str_to_time(string)`	Konwertuje tekst na czas.
`TekstWCzasDom(tekst)`	`tekst_na_czas_dom(tekst)`	`str_time_def(string)`	Kkonwertuje ciąg znaków (tekst) na wartość czasu.
`TekstWDatęCzasDom(tekst)`	`tekst_na_datę_czas_dom(tekst)`	`str_datetime_def(string)`	konwertuje ciąg znaków na wartość daty i czasu, a jeśli konwersja się nie powiedzie, zwraca zdefiniowaną przez programistę wartość domyślną.
`TekstWDatęCzas(tekst)`	`tekst_na_datę(tekst)`	`str_date(string)/code>`	Konwertuje tekst na datę i czas.
`TekstWDatęDom(tekst, wartość domyślna)`	`tekst_na_datę_dom(tekst, wartość domyślna)`	`str_date_def(string, wartość domyślna)`	Konwertuje string na datę. Jeśli konwersja się nie powiedzie, zwraca wartość domyślną.
`DataCzasZ(rok, miesiąc, dzień)`	`utwórz_datę(rok, miesiąc, dzień)`	`encode_date(rok, miesiąc, dzień)`	Tworzy wartość z podanych składowych daty.
`CzasZ(godzina, minuta, sekunda, milisekunda)`	`utwórz_czas(godzina, minuta, sekunda, milisekunda)`	`encode_time(godzina, minuta, sekunda, milisekunda)`	Tworzy wartość z podanych składowych czasu.
`RozłóżDatę(data, rok, miesiąc, dzień)`	`rozłóż_datę(data, rok, miesiąc, dzień)`	`decode_date(data, rok, miesiąc, dzień)`	Rozkłada wartość na rok, miesiąc i dzień.
`RozłóżCzas(czas, godzina, minuta, sekunda, milisekunda)`	`rozłóż_czas(czas, godzina, minuta, sekunda, milisekunda)`	`decode_time(czas, godzina, minuta, sekunda, milisekunda)`	Rozkłada wartość na godzinę, minutę, sekundę i milisekundę.
`NiebezpiecznyWskaźnikZAdresu(liczba całkowita)`	`adres_zmiennej(liczba całkowita)`	`ptr`	Konwertuje liczbę całkowitą na wskaźnik (Pointer). Bardzo niebezpieczne - używaj tylko, gdy masz absolutną pewność, co robisz. Zwykle używane do interakcji z niskopoziomowym kodem lub API
`@zmienna`	`@zmienna`	`@zmienna`	Operator pobrania adresu. Zwraca wskaźnik do zmiennej. Nie jest to konwersja, ale jest kluczowe dla pracy ze wskaźnikami.
`NiebezpiecznyAdresZWskaźnika`	`adres_zmiennej_z_wskażnika`	`int_ptr`	Operator pobrania adresu. Zwraca wskaźnik do zmiennej. Nie jest to konwersja, ale jest kluczowe dla pracy ze wskaźnikami.

Czytanie i piasnie w konsoli (5)

Nazwa polska poprzednia	Nazwa angielska V 1.0.1.0	Opis
`pisz()`	`print()`	Wypisuje dane na wyjście w konsoli bez dodawania znaku nowej linii. Przykład pisz('Hello World')..
`pisz_linie()`	`print_line()`	Wypisuje dane na wyjście w konsoli i dodaje znak nowej linii po wypisaniu. Można wypisywać wiele wartości, Przykład pisznl('Wartość a: ', a, ', wartość b: ', b).
`piszf()`	`--`	Pozwala na formatowanie wyjścia przy pomocy specyfikatorów formatu. Np. piszf('Liczba: %d, zmiennoprzecinkowa: %.2f', [liczba, zmiennoprzecinkowa]). Przykład: piszf('Imię: %s, Wiek: %d lat, Wzrost: %.2f', [Imie, Wiek, Wzrost]);
`czytaj('')`	`--`	Wprowadzanie danych przez użytkownika, odczytuje do napotkania znaku białego (spacja, tabulacja, enter) funkcja czytaj('Wpisz imię')
`czytajnl('')`	`--`	Wprowadzanie danych przez użytkownika, odczytuje całą linię (do znaku końca linii). Można odczytywać wiele zmiennych jednocześnie, np. czytajnl(a, b, c) przykład czytaj('Wpisz imię')

Specyfikatory formatu (4)

Specyfikatory formatu to specjalne sekwencje umieszczane w ciągu znaków (stringu), które informują funkcję formatującą piszf o sposobie konwersji i wyświetlenia podanych argumentów. Dzięki nim możesz kontrolować, w jaki sposób liczby, ciągi znaków i inne typy danych mają być przekształcone do postaci tekstowej.

Nazwa polska poprzednia	Nazwa angielska V 1.0.1.0	Opis
`%d`	`%d`	Format dla liczb całkowitych (decimal). Przkład: piszf('Wiek: %d lat', [wiek]).
`%f`	`%f`	Format dla liczb zmiennoprzecinkowych. Przykład: piszf('Wzrost: %f', [Wzrost])
`%.2f`	`%.2f`	Format dla liczb zmiennoprzecinkowych z dwoma miejscami po przecinku. Przykład: piszf('Wzrost: %.2f', [Wzrost])
`%s`	`%s`	Format dla ciągów znaków. Przykład: piszf('Imię: %s', [Imie])

Operacje arytmetyczne na liczbach (4)

Nazwa	Opis
`+`	Dodawanie a+b.
`-`	Odejmowanie a-b
`*`	Mnożenie a*b
`/`	Dzielenie a/b

Operacje porównawcze (7)

Znak	Opis
`=`	Równy, sprawdza, czy dwie wartości są równe. a=b.
`<>`	Różny, nie równy Sprawdza, czy dwie wartości są różne. Jest to przeciwieństwo =, a<>b
`>`	Większy niż, sprawdza, czy wartość po lewej stronie jest większa od wartości po prawej stronie. a>b
`<`	Mniejszy niż, sprawdza, czy wartość po lewej stronie jest mniejsza od wartości po prawej stronie. a
`>=`	Większy lub równy, sprawdza, czy wartość po lewej stronie jest większa lub równa wartości po prawej stronie. a>=b
`<=`	Mniejszy lub równy, sprawdza, czy wartość po lewej stronie jest mniejsza lub równa wartości po prawej stronie. a<=b
`=, <>, >, <, >=, <=`	Porównywanie tesktu

Operacje nad tekstem (17)

Nazwa polska	Nazwa angielska V 1.0.1.0	Opis
`+`	Konkatenacja – operacja łączenia dwóch lub więcej ciągów znaków napisów, tekstów w jeden dłuższy ciąg.
`czytaj_klawisz`	`read_key`	Odczytuje pojedynczy znak z klawiatury bez echa (nie wyświetla się na ekranie). Przydatne do obsługi interakcji z użytkownikiem (np. "Naciśnij dowolny klawisz, aby kontynuować"). Przykład. znak a = czytaj_klawisz pisz('Wybrany klawisz: ', a)
`klawisz_wciśnięty`	`--`	Sprawdza czy został naciśnięty klawisz. Przykład. program przycisknacisniety jeśli klawisz_wciśnięty wtedy pisz('Przycisk nacisniety') inaczej pisz('zaden przycisk nie nacisniety')
`długość(s)`	`--`	Zwraca długość tekstu s. Przykład. program dlugosctekstu tekst a = 'siema' liczba_całkowita i = 0 i = długość(a) pisznl('Tekst zawiera: ', LiczbacWTekst(i), ' znaków')
`kopiuj(źródło, początek, długość)`	`--`	Zwraca fragment tekstu źródło, zaczynając od pozycji początek (licząc od 1) i pobierając długość znaków. Parametry źródło – łańcuch wejściowy początek – indeks pierwszego znaku (1 = początek łańcucha) długość – liczba znaków do skopiowania Przykład1 Program kopiowanie tekst a = 'Ala' pisz_linie(a) tekst b = kopiuj(a, 1, 2); pisznl(b); // Al Przykład 2 Program kopiowanie tekst a = 'Ala'; tekst b = kopiuj(a, 1, 1); pisznl(b); // A
`wstaw(tekst, zmienna, indeks)`	`insert(tekst, zmienna, indeks)`	Wstawia podany tekst w określone miejsce w zmiennej. Przykład program alamakota tekst a = 'Ala ma kota' wstaw(' czarnego', a, 7) pisznl(a) // Wynik: Ala ma czarnego kota
`usuń(zmienna, indeks, ilość_znaków)`	`--`	Usuwa określoną liczbę znaków od podanej pozycji. Przykład program usuwanie tekst a = 'Ala ma kota' usuń(a, 1, 3) pisznl(a) // Wynik: ma kota
`duże_litery(s)`	`--`	Zamienia wszystkie litery w tekście na wielkie s - zmienna tekstowa. Przykład program duzelitery tekst a = 'siemka' a = duże_litery(a) pisznl(a) // Wynik: SIEMKA
`małe_litery(s)`	`--`	Zamienia wszystkie litery w tekście na małe. s - zmienna tekstowa. Przykład program malelitery tekst a = 'SIEMA' a = małe_litery(a) pisznl(a) // Wynik: siema
`przytnij(s)`	`trim(s)`	Usuwa spacje z początku i końca tekstu. Przykład program przycietytekst tekst a = ' siema ' a = przytnij(a) pisznl(a) // Wynik: siema
`przytnij_z_prawa(s)`	`trim_right(s)`	Usuwa spacje tylko z końca tekstu. Przykład program przycietytekst tekst b = ' Programista Art ' tekst c = 'Wita' tekst suma = przytnij_z_prawa(b) + c pisznl(suma) // Wynik: Programista ArtWita
`przytnij_z_lewa(s)`	`trim_left(s)`	Usuwa spacje tylko z początku tekstu. Przykład program przycietytekst tekst b = ' Programista Art' tekst c = c = przytnij_z_lewa(b) pisznl(b) pisznl(c) // Wynik: Programista Art
`powtórz_znak(znak, ilość)`	`repeat_char(znak, ilość)`	Tworzy tekst z powtarzającego się znaku. Przykład program powtorzenie znak a = 'b' liczba_całkowita ile = 10 pisznl(powtórz_znak(a, ile)) // Wynik: bbbbbbbbbb
`porównaj_tekst(s1, s2)`	`--`	Porównuje dwa napisy (uwzględnia wielkość liter) porównuję napisy, patrząc na ich zawartość od lewej do prawej. Porównanie kończy się w momencie, gdy napotka się pierwszą różnicę. Wynik porównania jest wtedy oparty na różnicy w wartościach kodów ASCII lub Unicode tych konkretnych, różnych znaków. Zwraca 0, jeśli są równe <0, jeśli s1 < s2 0, jeśli s1 > s2 Przykład program porownajtekst tekst a = 'Siema' tekst b = 'Programista' pisznl(porównaj_tekst(a, b)) // Wynik: 3 oznacza, że pierwszy napis ('siema') jest "większy" od drugiego ('programista').
`szukaj(szukany, tekst)`	`--`	Zwraca pozycję pierwszego wystąpienia znaku "szukany" w łańcuchu "tekst". Jeśli nie znajdzie – zwraca 0. Parametry szukany – znak lub słowo, którego szukamy tekst – zdanie, w którym szukamy Przykład 1 program szukajslowo tekst w = 'Cześć jestem programista' lc pozycja = szukaj('programista',w) pisznl(wynik) //odpowiedź 16 Przykład 2 program szukajslowowzdaniu tekst zdanie_testowe = 'Cześć jestem programista' tekst szukany_tekst = 'programista' lc pozycja = szukaj(szukany_tekst, zdanie_testowe) jeśli pozycja > 0 wtedy pisznl('znalezione: '+ szukany_tekst + ' pozycja: ' + LiczbacWTekst(pozycja)) inaczej pisznl('brak szukanego słowa')
`zamień_tekst(oryginalny_tekst, szukany_tekst, nowy_tekst)`	`--`	Zastępuje wszystkie wystąpienia szukany_tekst ciągiem nowy_tekst. Parametry Przykład 1 program przyklad_zamien_tekst tekst oryginalny_tekst = 'Ala ma kota.' tekst zmieniony_tekst = '' tekst szukany_tekst = 'kota' tekst nowy_tekst = 'psa' zmieniony_tekst = zamień_tekst(oryginalny_tekst, szukany_tekst, nowy_tekst) pisznl(zmieniony_tekst) // Wynik: Ala ma psa
`duże_litery_ansi(s)`	`--`	Zamienia tekst na WIELKIE litery, z obsługą polskich znaków Przykład program duze_litery tekst a = 'Zażółć gęślą jaźń' a = duże_litery_ansi(a) pisznl(a) // Wynik: ZAŻÓŁĆ GĘŚLĄ JAŹŃ

Instrukcja warunkowa Jeśli (1)

Nazwa polska V 1.0.1.3	Nazwa angielska V 1.0.1.3	Opis
`jeżeli.. wtedy .. inaczej`	`if ... then... else,`	Przykład użycia: program warunek liczba_całkowita a = 10 jeżeli a > 5 wtedy początek pisz_linie('a>5') koniec inaczej pisz_linie('a<5')	Przykład angielskie nazwy: program warunek liczba_całkowita a = 10 if a > 5 then start print_line('a>5') end else print_line('a<5')

Komentarze (2)

Nazwa	Opis
`//komentarz`	Jedna linia kodu zostanie zakomentowana
`(* kod *)`	Wielowierszowy komentarz

Rodzaje pętli (9)

Nazwa polska v 1.0.1.3	Nazwa angielska v 1.0.1.3	Opis
`dla .. do .. wykonać{}`	`for ... to ... do`	Używana, gdy z góry wiesz, ile razy chcesz wykonać kod. Licznik zmienia się automatycznie. Przykład polskie nazwy program forto lc i = 0 dla i = 1 do 4 wykonać pisz_linie(i)	Przykład angielskie nazwy program forto int i = 0 for i = 1 to 4 make print_line(i)
`przerwać`	`break`	Pomocnicza funkcja - natychmiast kończy pętlę Przykład polskie nazwy program fortobreak liczba_całkowita i = 0 dla i = 1 do 4 wykonać początek jeżeli i = 3 wtedy przerwać pisz_linie(i) koniec	Przykład angielskie nazwy program fortobreak int i = 0 for i = 1 to 4 do start if i = 3 then break print_line(i) end
`kontynuować`	`continue`	Pomocnicza funkcja - pomija resztę bieżącej iteracji i przechodzi do następnej Przykład polskie nazwy program fortobreak liczba_całkowita i = 0 dla i = 1 do 4 wykonać początek jeżeli i = 3 wtedy kontynuować pisz_linie(i) koniec	Przykład angielskie nazwy program fortobreak int i = 0 for i = 1 to 4 do start if i = 3 then continue print_line(i) end
`etykieta`	`label`	Pomocnicza funkcja etykieta / label to etykieta do skoków, używana razem ze słowem kluczowym jump / skocz. To taki „znacznik” w kodzie, do którego możesz przeskoczyć w dowolnym miejscu w obrębie tej samej procedury lub bloku. Przykład polskie nazwy program testlabel etykieta skok liczba_całkowita a = 6 jeżeli a = 5 wtedy początek pisz_linie('a równa się 5') koniec inaczej początek skocz skok pisz_linie('a nie równa się 5') koniec skok: pisz_linie('tu')	Przykład angielskie nazwy program testlabel label skok int a = 6 if a = 5 then start print_line('a równa się 5') end else start jump skok print_line('a nie równa się 5') end skok: print_line('tu')
`skocz`	`jump`	Pomocnicza funkcja skocz / jump Pozwala na skok do etykiety w obrębie procedury/bloku. Przykład polskie nazwy program testlabel etykieta skok liczba_całkowita a = 6 jeżeli a = 5 wtedy początek pisz_linie('a równa się 5') koniec inaczej początek skocz skok pisz_linie('a nie równa się 5') koniec skok: pisz_linie('tu')	Przykład angielskie nazwy program testlabel label skok int a = 6 if a = 5 then start print_line('a równa się 5') end else start jump skok print_line('a nie równa się 5') end skok: print_line('tu')
`malejąco`	`descending`	Pętla odliczanie w dół (downto) Przykład polskie nazwy program descendingtest lc i = 0 dla i = 5 malejąco 1 do pisz_linie('Liczba: ', i);	Przykład angielskie nazwy program descendingtest int i = 0 for i = 5 descending 1 do print_line('Liczba: ', i);
`powtarzaj ... aż`	`repeat ... until`	Podobna do while, ale warunek sprawdzany jest na końcu — czyli pętla wykona się przynajmniej raz. W repeat .. until warunek oznacza koniec pętli — czyli dopóki warunek jest False, pętla się powtarza. Przykład polskie nazwy program repeatuntil liczba_całkowita a = 1 powtarzaj pisz_linie('a: ', a) a = a + 1 aż a >5	Przykład angielskie nazwy program repeatuntil int a = 1 repeat print_line('a: ', a) a = a + 1 until a >5
`Pętla dopóki warunek wykonać`	`Pętla while warunek do`	Wykonuje się tak długo, jak warunek jest prawdziwy (True). Warunek sprawdzany jest przed każdą iteracją. Przykład polskie nazwy program test liczba_całkowita a = 1 dopóki a <= 5 wykonać początek pisz_linie(' a: ', a) a = a +1 koniec	Przykład angielskie nazwy program test int a = 1 while a <= 5 do start print_line(' a: ', a) a = a +1 end
`Pętla dla ... w ... wykonać`	`Pętla for ... in ... do`	Pętla for .. in .. do (pętla po kolekcjach) Używana do iteracji po tablicach, listach, zbiorach itp. Przykład polskie nazwy program test dla s w ['Ala', 'ma', 'kota'] wykonać pisz_linie(s)	Przykład angielskie nazwy program test for s in ['Ala', 'ma', 'kota'] do print_line(s)

Zarządzanie programem: (2)

Nazwa polska	Nazwa angielska	Opis
`zakończ(2)`	`--`	Natychmiastowe zakończenie programu. zakończ(2) kończy program z kodem wyjścia 2.
`wyjść`	`--`	Kończy bieżącą procedurę lub funkcję. Jeśli użyte w programie głównym, kończy program. Przykład program test lc a = 3 lc b = 10 lc suma = a+b jeśli suma < 10 wtedy wyjść inaczej pisznl('Nie wyłączam apkę')

Zarządzanie programem: (1)

Nazwa polska	Nazwa angielska	Opis
`informacje_o_wyszukaniu`	`--`	`search_record`	to struktura danych, która zbiera w jednym miejscu atrybuty pliku, takie jak nazwa, rozmiar, data modyfikacji i atrybuty. Jest używana głównie przez funkcje wyszukiwania plików, takie jak FindFirst i FindNext, które wypełniają jej pola odpowiednimi danymi.

Moduł matematyka (55)

Nazwa polska	Nazwa angielska	Opis
`oblicz('wyrażenie')`	`calc('wyrażenie')`	Główna funkcja która oblicza wyrażenia matematyczne i trygonometryczne. oblicz('(10+40+34)*2'). //Wynik 168 oblicz('2.3+3.0+40') //Wynik 45,30 oblicz('cos(0)') //Wynik 1
`oblicz_formatuj('pi'), 5)`	`calc_format('pi'), 2)`	Główna funkcja która oblicza wyrażenia matematyczne i trygonometryczne z uwzględniem ile liczb po przecinku wstawić.
`sin(x)`	`sin(x)`	Zwraca sinus kąta 'x' (w radianach). Argument i wynik są typu 'Liczba_rozszerzona' (typ zmiennoprzecinkowy o najwyższej precyzji).
`cos(x)`	`cos(x)`	Zwraca cosinus kąta 'x' (w radianach). Argument i wynik są typu 'Liczba_rozszerzona' Argument i wynik są typu 'Liczba_rozszerzona'.
`tan(x)`	`tan(x)`	Zwraca tangens kąta 'x' (w radianach). Argument i wynik są typu 'Liczba_rozszerzona' Uwaga: Dla kątów bliskich π/2 + kπ (gdzie tangens dąży do nieskończoności), wynik może być bardzo dużą liczbą lub może wystąpić błąd przepełnienia w zależności od kontekstu..
`arcsin(x)`	`arcsin(x)`	Zwraca arcus sinus wartości x. Wynik jest kątem w radianach w zakresie [-π/2, π/2]. Argument x musi należeć do przedziału [-1, 1]. Podanie wartości spoza tego zakresu spowoduje błąd wykonania (lub zwróci NaN - Not a Number).
`arcccos(x)`	`arcccos(x)`	Zwraca arcus cosinus wartości x. Wynik jest kątem w radianach w zakresie [0, π]. Argument x musi należeć do przedziału [-1, 1]. Podanie wartości spoza tego zakresu spowoduje błąd wykonania (lub zwróci NaN - Not a Number).
`arctan(x)`	`arctan(x)`	Zwraca arcus tangens wartości x. Wynik jest kątem w radianach w zakresie (-π/2, π/2).
`arctan2(x,y)`	`arctan2(x,y)`	Zwraca arcus tangens ilorazu y / x, ale bierze pod uwagę znaki obu argumentów (y i x), aby poprawnie określić ćwiartkę układu współrzędnych. Wynik jest kątem w radianach w zakresie (-π, π]). Jest to preferowana funkcja do obliczania kąta na podstawie współrzędnych (x, y), ponieważ `ArcTan(y/x)` nie rozróżnia między kątami różniącymi się o π (180 stopni). Jeśli 'x' i 'y' są oba równe 0, wynik jest zazwyczaj 0, ale zachowanie może zależeć od implementacji.
`degtorad(Stopień)`	`degtorad(Stopień)`	Konwertuje kąt podany w stopniach (Degrees) na radiany.
`dadtodeg(Radian)`	`dadtodeg(Radian)`	Konwertuje kąt podany w radianach na stopnie. Można też użyć wzorów: Radiany = Stopnie * Pi / 180, Stopnie = Radiany * 180 / Pi
`Pi`	`Pi`	Reprezentuje liczbę π z dużą precyzją.
`cotan(x)`	`cotan(x)`	Zwraca kotangens kąta 'x' (w radianach). Jest to równoważne '1 / Tan(x)' lub 'Cos(x) / Sin(x)''. Uwaga na dziedzinę: funkcja nie jest zdefiniowana dla 'x = kπ' (gdzie sinus jest równy 0)
`sinh(x)`	`sinh(x)`	Zwraca sinus hiperboliczny wartości x. (Obliczany jako (exp(x) - exp(-x)) / 2)
`cosh(x)`	`cosh(x)`	Zwraca cosinus hiperboliczny wartości x. (Obliczany jako (exp(x) - exp(-x)) / 2)
`tanh(x)`	`tanh(x)`	Zwraca tangens hiperboliczny wartości x. (Obliczany jako Sinh(x) / Cosh(x))
`arcsinh(x)`	`arcsinh(x)`	Zwraca arcus sinus hiperboliczny wartości x
`arctanh(x)`	`arctanh(x)`	Zwraca arcus tangens hiperboliczny wartości 'x'. Argument 'x' musi być w przedziale '(-1, 1)''.
`sec(x)`	`sec(x)`	Sekans kąta x to odwrotność jego cosinusa.. Przykład sec(x) = 1 / cos(x). Warunek: cos(x) nie może być równy zero (czyli x nie może być równe π/2 + kπ, gdzie k jest liczbą całkowitą).
`scc(x)`	`scc(x)`	Kosekans kąta x to odwrotność jego sinusa. sin(x) nie może być równy zero (czyli x nie może być równe kπ, gdzie k jest liczbą całkowitą). Przykład csc(x) = 1 / sin(x).
`arccot(x)`	`arccot(x)`	Warunek: x musi być różne od zera (x <> 0). Przykład: arcCot(x) = arctan(1/x)
`arcsec(x)`	`arcsec(x)`	Warunek: Wartość 1/x musi należeć do dziedziny ArcCos, czyli do przedziału [-1, 1]. Oznacza to, że x musi spełniać warunek \|x\| >= 1 (czyli x <= -1 lub x >= 1). Przykład: arcsec(x) = arccos(1/x)
`arccsc(x)`	`arccsc(x)`	Warunek: Podobnie jak wyżej, wartość 1/x musi należeć do dziedziny ArcSin, czyli do przedziału [-1, 1]. Oznacza to, że x musi spełniać warunek \|x\| >= 1 (czyli x <= -1 lub x >= 1). Przykład: arccsc(x) = arcsin(1/x)
`arccosh(x)`	`arccosh(x)`	Funkcja obliczająca arcus cosinus hiperboliczny (odwrotny cosinus hiperboliczny).
`coth(x)`	`coth(x)`	Funkcja kotangens hiperboliczny.
`ccsch(x)`	`ccsch(x)`	Funkcja kosekans hiperboliczny. Kosekans hiperboliczny jest zdefiniowany jako odwrotność sinusa hiperbolicznego csch(x) = 1 / sinh(x)
`sech(x)`	`sech(x)`	Funkcja sekans hiperboliczny. Sekans hiperboliczny jest zdefiniowany jako odwrotność cosinusa hiperbolicznego sech(x) = 1 / cosh(x)
`csc(x)`	`csc(x)`	Funkcja kosekans. Kosekans kąta x to odwrotność jego sinusa csc(x) = 1 / sin(x)
`abs(x)`	`abs(x)`	Funkcja Wartość bezwzględna liczby x oblicz('abs(-5)') // Wynik: 5
`sqr(x)`	`sqr(x)`	Funkcja Kwadrat liczby x. oblicz('sqr(4)') // Wynik: 16
`sqrt(x)`	`sqrt`	Funkcja Pierwiastek kwadratowy z liczby x (liczba musi być nieujemna). oblicz('sqrt(9)') // Wynik: 3
`ln(x)`	`ln(x)`	Funkcja Logarytm naturalny. oblicz('ln(5)') // Wynik: 1.61
`power(x, y)`	`power(x, y)`	Funkcja Potęgowanie (podstawa do potęgi wykładnik). oblicz('power(2,3)') // Wynik: 8
`zwiększ(x)`	`inc(x)`	Funkcja Inkrementuje zmienną x (zwiększa o 1). oblicz('zwiększ(5)') // Wynik: 6
`zmniejsz(x)`	`dec(x)`	Funkcja Dekrementuje zmienną x (zmniejsza o 1). oblicz('zmniejsz(5)') // Wynik: 4
`ułamek(x)`	`--`	Funkcja Zwraca część ułamkową liczby zmiennoprzecinkowej. oblicz('ułamek(3.1415)') // Wynik: 0.1415
`losuj()`	`randomize()`	Inicjalizuje generator liczb losowych. Należy wywołać przed pierwszym użyciem random() lub losowy(), aby wyniki nie były powtarzalne przy każdym uruchomieniu
`losowy(max)`	`random(max)`	Random(max), które zwraca losową liczbę z zakresu 0..max-1 program randomowa randomize() //Losowa liczba maksymalna 100 int a = random(100) print_line(a)
`Int(X)`	`Int(X)`	Zwraca część całkowitą z liczby rzeczywistej X (jako Real)
`odd(x)`	`odd(x)`	Sprawdza, czy liczba całkowita X jest nieparzysta (zwraca Boolean). Odd(int) → Boolean
`log10(x)`	`log10(x)`	Logarytm dziesiętny (log10(X)).
`log2(x)`	`log2(x)`	Logarytm binarny (log2(X)).
`sufit(x)`	`ceil(x)`	Zaokrągla w górę.
`podłoga(x)`	`floor(x)`	Zaokrągla w dół.
`hypot(x,y)`	`hypot(x,y)`	Przeciwprostokątna (X2+Y2).
`min(x,y)`	`min(x,y)`	Zwrac mniejszą liczbę z dwóch wartości.
`maks(x,y)`	`max(x,y)`	Zwrac większą liczbę z dwóch wartości.
`zaokrąglić(2.3)`	`round(2.3)`	Zaokrąglenie liczby rzeczywistej do najbliższej liczby całkowitej.
`czy_jest_nan(x)`	`is_nan(x)`	Sprawdza, czy wartość jest Not a Number (np. wynik Sqrt(−1)).
`isinfinite(x)`	`isinfinite(x)`	Sprawdza, czy wartość jest nieskończona.
`isnanorinfinity(x)`	`isnanorinfinity(x)`	Określa, czy wartość zmiennoprzecinkowa X jest nieprawidłową liczbą (NaN) LUB nieskończonością (dodatnią +∞ lub ujemną −∞). Zastosowanie: Używa się jej do szybkiego sprawdzenia, czy wynik operacji zmiennoprzecinkowej jest niepoprawny lub nieokreślony w sensie arytmetyki IEEE 754, co często wymaga specjalnej obsługi, aby zapobiec błędom w dalszych obliczeniach.
`iszero(A,[Epsilon])`	`iszero(A,[Epsilon])`	Służy do sprawdzania, czy podana liczba zmiennoprzecinkowa A jest bliska zeru z uwzględnieniem tolerancji błędów obliczeniowych.
`isnegative(X)`	`isnegative(X)`	Służy do sprawdzenia, czy wartość zmiennoprzecinkowa X jest ujemna, w tym również ujemna nieskończoność (−∞) i ujemne zero (−0.0).
`isnanorinf(X)`	`isnanorinf(X)`	Sprawdza, czy wartość zmiennoprzecinkowa X jest nieprawidłową liczbą (NaN) LUB nieskończonością (+∞ lub −∞). Funkcja zwraca True, jeśli: IsNaN(X)∨IsInfinite(X) Wartość zwracana Typ logiczny (Boolean).
`odcięcie(X)`	`trunc(X)`	Ucina część ułamkową liczby rzeczywistej X (w kierunku zera).

Moduł internet (3)

Nazwa polska	Nazwa angielska	Opis
`ping('https://avocado.doc.dimitalart.pl/')`	`ping('https://avocado.doc.dimitalart.pl/')`	Funkcja sprawdza, czy dana strona odpowiada. Przykład program pinguje importuj internet tekst witaj = 'Witaj w programie PING' pisznl(witaj) //pisznl(ping('www.programista.art')) jeśli ping('www.programista.art') wtedy pisznl('Strona www.programista.art odpowiada!') inaczej pisznl('Nie można nawiązać połączenia z programista.art')
`pobierz_plik(‘nazwa pliku’,’gdzie zapisać + nazwa pliku’)`	`--`	Pobiera plik z internetu i zapisuje go w wskazanej lokalizacji. Przykład program pob pobierz_plik('https://avocado.doc.dimitalart.pl/ustawienia.jpg', 'D:\bazy\info\ustawienia.jpg')
`pobierz_strone(‘nazwa pliku’, lista_tekstów, ’gdzie zapisać + nazwa pliku’)`	`--`	Pobiera stronę internetową, zapisuje jej zawartość w zmiennej typu lista_tekstów i do pliku. Przykład. program pobarnie lista_tekstów a = nic pobierz_strone('https://avocado.dimitalart.pl/', a, 'D:\bazy\info\strona.html') pisznl('Zawartość pobranej strony:') pisznl(a.tekst)

Operacje na plikach (11) W trakcie realizacji

Nazwa polska	Nazwa angielska	Opis
`przypisz_plik(f,nazwa_pliku)`	`assign_file(f,nazwa_pliku)`	Przypisuje zmienną plikową f do pliku o nazwie nazwa_pliku.
`otwórz_do_odczytu(f)`	`open_read(f)`	Otwiera plik do odczytu.
`otwórz_do_zapisu(f)`	`open_save(f)`	Otwiera plik do zapisu. Jeśli plik istnieje, jego zawartość jest nadpisywana.
`otwórz_do_dopisywania(f) lub dopisz(f)`	`append(f)`	Otwiera plik do dopisywania. Nowe dane są dodawane na końcu istniejącego pliku.
`zamknij_plik(f)`	`close_file(f)`	Zamyka plik. Bardzo ważne, aby zawsze zamykać pliki po zakończeniu pracy z nimi.
`zamknij_plik(f)`	`zamknij_plik(f)`	Zamyka plik. Bardzo ważne, aby zawsze zamykać pliki po zakończeniu pracy z nimi.
`koniec_pliku(f)`	`eof(f)`	Sprawdzanie końca pliku, także w wyrażeniach/warunkach "prawda"jeśli osiągnięto koniec pliku, w przeciwnym razie "falsz"
`zapisz_linie(zmienna f: plik_tekstowy; tekst)`	`--`	Zapis do pliku
`zapisz(zmienna f: plik_tekstowy; tekst)`	`--`	Zapis do pliku
`czy_istnieje_plik(nazwa) logiczny`	`file_exists(nazwa) logiczny`	Sprawdzanie czy plik istnieje
`wynik_io`	`--`	Zwraca kod błędu ostatniej operacji wejścia/wyjścia. Ważne do sprawdzania, czy operacje na plikach (otwieranie, zapis, odczyt) powiodły się. Jeśli IOResult <> 0, wystąpił błąd

Operacje na katalogach (8)

Nazwa polska	Nazwa angielska	Opis
`zmień_katalog('ścieżka')`	`change_dir('path')`	Zmienia bieżący katalog.
`utwórz_katalog('ścieżka')`	`create_dir('path')`	Tworzy nowy katalog.
`usuń_katalog('ścieżka')`	`remove_dir('path')`	Usuwa katalog (katalog musi być pusty).
`pobierz_katalog_bieżący`	`get_current_dir`	Zwraca ścieżkę do bieżącego katalogu
`czy_istnieje_katalog('ścieżka')`	`directory_exists('path')`	Sprawdza, czy katalog istnieje. (z SysUtils)
`parametr_programu(index)`	`get_argument(index)`	Zwraca parametr o numerze index przekazany do programu z linii poleceń
`pobierz_zmienną_środowiskową(nazwa)`	`get_env(name)`	Zwraca wartość zmiennej środowiskowej o podanej nazwie.
`ustaw_zmienną_środowiskową`	`set_env`	Ustawia zmienną środowiskową.

Import Modułów (1)

Nazwa polska	Nazwa angielska	Opis
`importuj nazwa-modułu`	`import nazwa-modułu`	Importuje moduł pascala do projektu.

Fragmenty kodu w innych językach(3)

Nazwa polska	Nazwa angielska	Opis
`asm { kod asemblera } →`	`import nazwa-modułu`	Wstawienie kodu asemblera w Avocado Przykład Przykład asm{ asm mov eax, 7 mov ebx, 8 imul eax, ebx mov wynik, eax end; }
`pascal{kod pascala}`	`pascal{kod pascala}`	Wstawienie bloku kodu pascala w Avocado pascal{ if liczba > 0 then WriteLn('Liczba jest dodatnia.') else if liczba < 0 then WriteLn('Liczba jest ujemna.') else WriteLn('Liczba jest równa zero.'); }
`pascal_line{kod pascala}`	`pascal_linia{kod pascala}`	Wstawienie kodu pascala w jednej linii w Avocado pascal_line{writeLn('Hello World')}

Obiekty (3)

Nazwa polska	Nazwa angielska	Opis
`lista_tekstów`	`-`	lista_tekstów to typ danych oparty na klasie. Posiada on: Właściwości: Atrybuty, które przechowują dane, np. liczba elementów na liście. Metody: Funkcje i procedury, które wykonują operacje na danych, np. dodaj_element (dodaje element), usuń_element (usuwa element), sortuj_element (sortuje listę). Zdarzenia: Mechanizmy do reagowania na akcje użytkownika lub systemu. Te cechy są charakterystyczne dla obiektów. Zmienną typu TStringList deklaruje się, tworzy i używa w sposób typowy dla obiektów, co odróżnia ją od prostych typów, takich jak liczba_całkowita czy tekst.
`.tekst`	`.text`	Dane z lista_tekstów wstaw w tekst: Przykład program pobarnienowe tekst c = '' lista_tekstów a = nic c = czytajnl('Podaj link do strony: ' ) pobierz_strone(c,a,'D:\bazy\info\strona.html') pisznl('Zawartość pobranej strony:') pisznl(a.tekst)
`zwolnij`	`free`	Funkcja zwolnij / free oznacza zwolnij zasób z pamięci

Kolory (18)

Nazwa polska	Nazwa angielska	Opis
`pozycja_kursora(x,y)`	`-`	Ustawianienie kursora w określonej pozycji w oknie konsoli. Przykład: program dlugosctekstu tekst a = 'siema' liczba_całkowita i = 0 i = długość(a) pisznl('Tekst zawiera: ', LiczbacWTekst(i), ' znaków')
`tło_tekstu`	`-`	Ustawianie koloru tła tekstu
`kolor_tekstu`	`-`	Ustawianie koloru tekstu w konsoli.
`czarny`	`black`	Kolor czarny lub użyj liczbę 0.
`zielony`	`green`	Kolor zielony lub użyj liczbę 2.
`żółty`	`yellow`	Kolor żółty lub użyj liczbę 24.
`niebieski`	`blue`	Kolor niebieski lub użyj liczbę 1.
`biały`	`white`	Kolor biały lub użyj liczbę 15.
`cyjan`	`cyan`	Kolor cyjan lub użyj liczbę 3.
`czerwony`	`red`	Kolor czerwony lub użyj liczbę 4.
`magenta`	`magenta`	Kolor magenta lub użyj liczbę 5.
`brązowy`	`brown`	Kolor brązowy lub użyj liczbę 6.
`jasnoszary`	`light_gray`	Kolor jasnoszary lub użyj liczbę 7.
`ciemnoszary`	`dark_gray`	Kolor ciemnoszary lub użyj liczbę 8.
`jasnoniebieski`	`light_blue`	Kolor jasnoniebieski lub użyj liczbę 9..
`jasnozielony`	`light_green`	Kolor jasnozielony lub użyj liczbę 10.
`jasnoczerwony`	`light_red`	Kolor jasnoczerwony lub użyj liczbę 12.
`jasnoróżowy`	`light_magenta`	Kolor jasnoróżowy lub użyj liczbę 13.
`migotanie`	`blink`	migotanie lub użyj liczbę 128.

Przykłady kodu 💻

🔹 Wyświetlenie "Hello World"

program hello
pisz('Hello World')

🔹 Deklaracje zmiennych po polsku

program deklaracje
                    // Liczba całkowita (Integer)
                    liczba_całkowita age = 18

                    // Liczba zmiennoprzecinkowa (Real)
                    liczba_zm procent = 5.5

                    // Wartość logiczna (Boolean)
                    logiczny programowac = prawda

                    // Znak (Char)
                    znak a = 'D'
                    pisz(a)

                    // Tekst (String)
                    tekst imie = 'Jan'

                    🔹 Deklaracje zmiennych po angielsku
                    program deklaracje
                    // Liczba całkowita (Integer)
                    int age = 18

                    // Liczba zmiennoprzecinkowa (Real)
                    real procent = 5.5

                    // Wartość logiczna (Boolean)
                    bool programowac = prawda

                    // Znak (Char)
                    char a = 'D'
                    print(a)

                    // Tekst (String)
                    string imie = 'Jan'

🔹 Tablice

program tablica-liczb
                    // Tablica Liczb (array of integer)
                    tablicaLiczb wiek = [20,30,40,50]
                    liczba_całkowita i = 0
                    dla i od 0 do 3 {pisz(wiek[i])}

                    // Tablica Tekstów (array of string)
                    tablicaTekstów przedmioty = ['Matematyka', 'Polski', 'Angielski']
                    pisz('Pierwszy przedmiot: ' + przedmioty[1])
                    liczba_całkowita i = 0
                    dla i od 0 do 2 {pisz(przedmioty[i])}

🔹 Pętle

program petla-for
                    // Pętla for
                    liczba_całkowita i = 0
                    dla i od 5 do 10 { pisz(i) }

🔹 Konwersja typów

program konwersje
                    // Liczba rzeczywista → Tekst
                    liczba_zm a = 5.5
                    tekst b = LiczbarWTekst(a)
                    pisz(b)

                    // Liczba całkowita → Tekst
                    liczba_całkowita a = 5
                    tekst b = LiczbacWTekst(a)
                    pisz(b)

                    // Tekst → liczbę całkowitą
                    tekst a = '5'
                    liczba_całkowita b = TekstWLiczbac(a)
                    pisz(b)

                    // Dodawanie po konwersji
                    tekst a = '5'
                    liczba_całkowita b = TekstWLiczbac(a)
                    liczba_całkowita suma = b + 10
                    pisz(suma)

🔹 Operacje arytmetyczne polskie nazwy

program matematyka
                    // Dodawanie
                    liczba_całkowita a = 5
                    liczba_całkowita b = 15
                    liczba_całkowita suma = a + b
                    pisz(suma)  // Wynik: 20

                    // Odejmowanie
                    liczba_całkowita a = 5
                    liczba_całkowita b = 15
                    liczba_całkowita wynik = a - b
                    pisz(wynik)  // Wynik: -10

                    // Mnożenie
                    liczba_całkowita a = 5
                    liczba_całkowita b = 15
                    liczba_całkowita iloczyn = a * b
                    pisz(iloczyn)  // Wynik: 75

                    // Dzielenie
                    liczba_całkowita a = 5
                    liczba_całkowita b = 15
                    liczba_zm wynik = b / a
                    pisz(wynik)  // Wynik: 3.0
                    🔹 Operacje arytmetyczne angielksie nazwy
                    program matematyka
                    // Dodawanie
                    int a = 5
                    int b = 15
                    int suma = a + b
                    print(suma)  // Wynik: 20

                    // Odejmowanie
                    int a = 5
                    int b = 15
                    int wynik = a - b
                    print(wynik)  // Wynik: -10

                    // Mnożenie
                    int a = 5
                    int b = 15
                    int iloczyn = a * b
                    print(iloczyn)  // Wynik: 75

                    // Dzielenie
                    int a = 5
                    int b = 15
                    razl wynik = b / a
                    print(wynik)  // Wynik: 3.0

🔹 Pobieranie danych od użytkownika polskie nazwy

program dane
                    tekst name = czytaj('Twoje imię: ')
                    tekst surname = czytaj('Twoje nazwisko: ')
                    tekst wynik = name + ' ' + surname
                    pisz_linie(wynik)

🔹 Formatowanie danych

program form
                    program forma
                    importuj formatowanie
                    tekst imie = 'Anna'
                    liczba_całkowita wiek = 30
                    liczba_zm wzrost = 1.57
                    liczba64 pesel = 12345678901

                    piszf('Dane użytkownika:', [])
                    piszf('Imię: %s', [imie])
                    piszf('Wiek: %d lat', [wiek])
                    piszf('Wzrost: %.2f m ', [wzrost])
                    piszf('Pesel: %.d ', [pesel])
                    piszf('Zapisano: %.d%% danych ', [100])
                    piszf('Imię: %s, Wiek: %d lat, Wzrost: %.2f', [imie, wiek, wzrost])

                    piszf('Wzrost: %f', [wzrost])
                    piszf('Wzrost: %.2f', [wzrost])

🔹 Komentowanie kodu

program hello
                    pisz('Siema')
                    //pisz('Siema') będzie ignorowane przez kompilator

🔹 Warunki

program warunki
                    // Instrukcja if-else
                    liczba_całkowita a = 5
                    jeśli a > 10 wtedy pisz('a jest większa od 10')
                    inaczej pisz('a jest mniejsza lub równa 10')

🔹 Konkatenacja tekstów

program klient
                    tekst imie = 'Jan'
                    tekst nazwisko = ' Kowalski'
                    tekst klient = imie + nazwisko
                    pisz(klient)  // Wynik: Jan Kowalski

🔹 Moduł matematyczny

program obliczenia
                    importuj matematyka
                    oblicz('(10+40+34)*2')
                    oblicz('2.3+3.0+40')
                    oblicz('cos(0)')
                    oblicz('cos(pi/2)')
                    oblicz('2 * sin(pi/6)')
                    oblicz('cosh(0)')
                    oblicz('arcsin(0.5) * 180/pi')
                    oblicz('sinh(1)')
                    oblicz('cosh(0)')
                    oblicz('2.3+3.0')
                    oblicz('arccos(0.5) * 180/pi')
                    oblicz('arccot(1)')
                    oblicz('arcsec(2)')
                    oblicz('arccsc(2)')

program losowanie liczby
                    program randomowa
                    randomize()
                    //Losowa liczba maksymalna 100
                    int a = random(100)
                    print_line(a)

Polski język programowania