Elementy języka REXX

W poprzedniej części kursu napisaliśmy pierwszy program oraz poznaliśmy podstawowe zagadnienia związane z REXXem. Ten wpis jest uzupełnieniem poprzedniego o dodatkowe elementy języka.

<<następna cześć artykułu poprzednia część artykułu>>

1. Operatory i wyrażenia

Operator to konstrukcja języka, która przyjmuje jedną lub więcej argumentów i zwraca nową wartość.

Operatory arytmetyczne:

Operator

Opis

+

Dodawanie

Odejmowanie

*

Mnożenie

/

Dzielenie

%

Dzielenie całkowite

//

Modulo, reszta z dzielenia

**

Potęgowanie

 

Przykłady działania operatorów z powyższej tabeli:

/* rexx */

Say 7 + 2; /* Dodawanie, zwraca: 9 */

Say 7 2; /* Odejmowanie, zwraca 5 */

Say 7 * 2; /* Mnożenie, zwraca 11 */

Say 7 / 2; /* Dzielenie, zwraca 3.5 */

Say 7 % 2; /* Dzielenie całkowite, zwraca 3 */

Say 7 // 2; /* Dzielenie modulo, zwraca 1 */

Say 7 ** 2; /* Potęgowanie, zwraca 49 */

Exit 0

 

Jednym z ciekawszych i mogących pozostawić wątpliwości jest operator //. Określa on dzielenie z resztą, nazywany też inaczej dzieleniem modulo. W zrozumieniu działania modulo mogą pomóc poniższe przykłady:

 

/* rexx */

Say 3 // 2; /* Zwraca 1, liczba nieparzysta */

Say 4 // 2; /* Zwraca 0, liczba parzysta */

Say 25 // 2; /* Zwraca 1, liczba nieparzysta */

Say 60 // 2; /* Zwraca 0, liczba parzysta */

Say 25 // 5; /* Zwraca 0, liczba podzielna przez 5 */

Say 13 // 5; /* Zwraca 3, liczba niepodzielna przez 5 */

Exit 0

 

Kolejność operatorów:

Za pomocą operatorów tworzymy tak zwane wyrażenia, sposób obliczenia ich wartości określają priorytety operatorów. Priorytety nie różnią się od tych jakich uczeni jesteśmy w szkole podstawowej, ale w ramach przypomnienia poniżej tabelka oraz kilka przykładów.

Priorytet

Operator

1

()

2

**

3

*, /, %, //

4

+, –

 

Przykłady:

/* rexx */

Say 8 * 3 + 5; /* Wynik 29 */

Say 8 + 3 * 5; /* Wynik 29 */

Say 8 3 + 5; /* Wynik 10 */

Say 8 + 3 5; /* Wynik 6 */

Say 3 ** 3 ** 2; /* Wynik 729 */

Say 3 ** (3 ** 2); /* Wynik 19683 */

Say 5 + 8 * 2 /* Wynik 21 */

Say (5 + 8) * 2 /* Wynik 26 */

Exit 0

 

Operatory porównania:

 

Operatory porównania opisuje tabelka, nie będę prezentował tutaj przykładów z nimi związanych ponieważ będą one miały szerokie zastosowanie przy omawianiu pętli i instrukcji warunkowych.

Operator

Opis

=

Równy

\=, <>, ><

Nie równy

<=, \>

Mniejszy równy

>=, \<

Większy równy

<

Mniejszy

>

Większy

 

Zawsze porównywany jest operand stojący po lewej stronie do operanda stojącego po prawej.

Operatory logiczne:

Wyrażenia logiczne zawsze zwracają jedną wartość: 0 jeśli fałsz, 1 jeśli prawda.

Operator

Opis

&

i

|

lub

&&

różnica symetryczna

\

nie

 

Przykłady:

/* rexx */

i = 0;

y = 1;

Say i & y; /* Wynik 0 (fałsz) */

Say i | y; /* Wynik 1 (prawda) */

Say i && y; /* Wynik 1 (prawda) */

Say\i; /* Wynik 1 (prawda) */

Exit 0

 

2. Porównywanie zmiennych

Po zapoznaniu się z operatorami zobaczmy jak REXX zachowuje się w przypadku porównania różnych typów danych. W przypadku ciągu znaków wyróżniamy dwa typy porównania: „normalny” i „dokładny”. Typ normalny (operator „=”) ignoruje spacje oraz porównuje wartość, natomiast w dokładnym (operator „==”) każdy znak musi być dokładnie taki sam oraz w tym samym miejscu. Każdy z typów rozróżnia wielkość liter.

/* rexx */

Str_var = ” STRING „;

Int_var = 5;

Say „Porównanie normalne”;

Say Str_var = „STRING”; /* Wynik 1 (prawda) */

Say Str_var = „string”; /* Wynik 0 (fałsz) */

Say Int_var = 5.0; /* Wynik 1 (prawda) */

Say „Porównanie dokładne”;

Say Str_var == „STRING”; /* Wynik 0 (fałsz) */

Say Str_var == ” STRING ” /* Wynik 1 (prawda) */

Say Str_var == ” string ” /* Wynik 0 (fałsz) */

Say Int_var == 5.0; /* Wynik 0 (fałsz) */

Exit 0

 

Przy porównywaniu zmiennych liczbowych REXX wykorzystuje porównanie normalne. Zobaczmy kilka przykładów:

/* rexx */

num_var1 = 15;

num_var2 = 20;

Say num_var1 = num_var2; /* Wynik 0 (fałsz) */

Say num_var1 \= num_var2; /* Wynik 1 (prawda) */

Say num_var1 > num_var2; /* Wynik 0 (fałsz) */

Say num_var1 < num_var2; /* Wynik 1 (prawda) */

Exit 0

3. Sterowanie przebiegiem wykonania (instrukcje sterujące)

Wszystkie instrukcje sterujące określają kolejne instrukcje do wykonania na podstawie prawdziwości lub fałszywości wyrażenia warunkowego. Można je porównać do decyzji, które program podejmuje na podstawie precyzyjnie zaprogramowanych reguł. Przyjrzyjmy się tym konstrukcjom bliżej:

Instrukcja If –Then:

Algorytm:

Przykład:

/* rexx */

Say „REXX jest fajny”;

Pull Str_var1;

If Str_var1 = „TAK” Then;

Say „Też tak sądzę :-)”;

Say „Podaj liczbę”

Pull Num_var1;

If Datatype(Num_var1,N) Then;

Say „Podałeś liczbę: „Num_var1;

Exit 0

 

Instrukcja If–Then-Else:

Algorytm:

Przykład:

/* rexx */

Say „REXX jest fajny”;

Pull Str_var1;

If Str_var1 = „TAK” Then;

Say „Też tak sądzę :-)”;

Else

Say „Nie rozumiem twojej odpowiedzi”;

Say „Podaj liczbę”

Pull Num_var1;

If Datatype(Num_var1,N) Then;

Say „Podałeś liczbę: „Num_var1;

Else

Say „Nie podałeś liczby”;

Exit 0

 

Instrukcja Do-End, Do-While, Do-Forever oraz Do-Until

Do-End służy do grupowania pewnej części kodu. Jeśli po instrukcji warunkowej potrzebujemy wykonać kilka instrukcji to umieszczamy je pomiędzy Do a End, możemy też określić ile razy dana część kodu ma się wykonać. Przykład:

/* rexx */

If 1 = 1 Then

Do /*Do End wykorzystane do grupowania */

Say „Tak to prawda”;

Callsubroutine arg2 arg2 /* Call wywołuje procedurę */

End

i = 10;

Do j = 1 To i By 2 /* Pętla zwiększająca się o 2 */

Say „j = „j;

End

x = 5;

Do f = 1 To x /* Pętla bez By domyślnie zwiększająca się o 1*/

Say „f = „f;

End

y = 0;

Do 4 /* Do z określona liczbą wykonań */

Say 1 + y;

y = y + 1;

End

Exit 0

 

Instrukcja Do-While:

 

Algorytm:

Przykład:

/* rexx */

i = 15;

Do While i >= 1

Say „i = „i;

i = i 1;

End

Exit 0

 

Instrukcja Do-Until:

 

Do-Until jest odwrotnością pętli Do-While

Przykład:

/* rexx */

Int_var1 = 1

Do Until Int_var1 > 10

Say „Int_var1 = „Int_var1;

Int_var1 = Int_var1 + 1;

End

Exit 0

 

Instrukcja Do-Forever:

Z tą instrukcją silnie związane są dwie instrukcje, bez których jej przydatność była by dyskusyjna, mowa o Leave oraz Iterate. Przykład zastąpi milion słów:

/* rexx */

i = 1;

Do Forever

i = i + 1;

Say „i = „i;

If i = 10 Then Leave /* jeśli i=10 opuść pętlę */

End

Say „===========”;

y = 1;

Do Until y = 5

y = y + 1;

Say „y = „y;

if y > 1 Then Iterate /* jeśli y>1 wróć do początku pętli*/

Say „Ta linia kodu nigdy się nie wykona”;

End

Exit 0

 

Instrukcja Select:

Algorytm:

Przykład:

/* rexx */

Say „Jaki jest twój ulubiony język programowania”;

Pull Str_var1;

Select

When Str_var1 = „REXX” Then

Say „Super”;

When Str_var1 = „JAVA” Then

Do

Say „Rewelacja”;

Say „Ten program jest napisany w REXXie”;

End

Otherwise

Say „Lubisz „Str_var1;

Say „================”;

End

Exit 0

 

Sporo przykładów w tej części kursu, a zwłaszcza tych dotyczących instrukcji sterujących pozbawione jest komentarzy, zrobiłem tak celowo aby zachęcić do przetestowania wyników samemu, co na pewno pozwoli na lepsze zrozumienie tematu.

 Autor: Dawid Morawiec

Komentarze

Brak komentarzy

The comments are closed.

Follow

Otrzymuj każdy nowy wpis na swoją skrzynkę e-mail.

Subskrybuj RSS