PAU wyklady z roku 13

  1. JĘZYK HTML

    1. Podstawowa struktura dokumentu HTML

<HTML>

<HEAD>

GŁOWA DOKUMENTU – w tej części wpisujemy informacje o dokumencie

</HEAD>

<BODY>

CIAŁO DOKUMENTU – zasadnicza część dokumentu. Wpisywane są tu elementy do wyświetlenia na stronie www

</BODY>
</HTML>

Przykładowe elementy wpisywane w części HEAD:

    2. Podstawowe znaczniki w języku html

Znaczniki html umieszczane są w nawiasach ostrych (np. <znacznik>). Większość znaczników posiada otwarcie i zamknięcie. W przypadku tych znaczników elementy których dotyczyć mają znaczniki wpisujemy pomiędzy nie (np. <znacznik> tekst, którego się tyczy znacznik </znacznik>).

Przykładowe znaczniki bez zamknięcia:

Przykładowe znaczniki z zamknięciem:

Do niektórych znaczników można zastosować parametry np. wyśrodkowanie, kolor. Parametry zawsze wpisuje się w znaczniku otwierającym.

Przykłady znaczników z parametrami:

Do formatowania czcionki służy znacznik FONT. Formatowany tekst umieszczany jest między znacznik otwierający a zamykający (np. <font> tekst </font>)

Przykładowe parametry dla znacznika font:

pRZYKŁAD DO CZĘŚCI 1.1, 1.2 ORAZ 1.3

<HTML>

<HEAD>

<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-2">

<TITLE> PRZYKŁAD </TITLE>

</HEAD>

<BODY>

<P align=center>

<B>TO JEST PRZYKŁAD POGRUBIENIA</B>

</P>

<HR width=400, color=blue>

<P align=center>

<font color=red> A to przykład formatowania czcionki </font><br>

<font size=-2> -2 i czcionka zmniejszona </font>

</P>

</BODY>

</HTML>

TABELE

Znaczniki tworzenia tabel:

Przykładowe parametry znaczników tabeli:

Żeby zdefiniować tabelę należy najpierw utworzyć tabelę poprzez znacznik TABLE. Potem zdefiniować wiersz tabeli przez znacznik TR a następnie w każdym wierszu zdefiniować komórki. Zawartość tabeli wpisujemy w poszczególne komórki (między znaczniki komórek). Przykład:

PRZYKŁAD TWORZENIA TABELI

<HTML>

<HEAD>

<TITLE> PRZYKŁAD </TITLE>

</HEAD>

<BODY>

<TABLE border=2, bordercolor=#1475729, width=150>

<TR>

<TD> Jeden </TD> <TD> Dwa </TD>

</TR>

<TR>

<TD> Trzy </TD> <TD> Cztery </TD>

</TR>

</TABLE>

</BODY>

</HTML>

Wyrównywanie tekstu w tabeli/komórce:

Scalanie komórek tabeli:

Parametry te umieszczamy w znaczniku komórki (TD)

Należy pamiętać że w kodzie html definiujemy jedynie pierwszą ze scalonych komórek

Przykład scalania komórek i wyrównywania tekstu

<HTML>

<HEAD>

<META HTTP-EQUIV="content-type" CONTENT="text/html; charset=iso-8859-2">

<TITLE> SZABLON HTML </TITLE>

</HEAD>

<BODY>

<TABLE border=2 width=800>

<TR><TD align=left>Wyrównanie do lewej</TD><TD align=center>Wyśrodkowanie</TD><TD align=right>Wyrównanie do prawej</TD></TR>

<TR height=50><TD colspan=3 align=center valign=middle>Scalone i wyśrodkowane (w pionie i poziomie) komórki</TD> </TR>

<TR><TD rowspan=2 align=right valign=top>scalone w pionie</TD><TD>tekst</TD><TD rowspan=2 align=left valign=bottom>scalone w pionie</TD></TR>

<TR><TD>przykładowy tekst</TD></TR>

</TABLE>

</BODY>

</HTML>

wstawianie grafiki

Do wstawiania grafiki służy znacznik <IMG SCR= „adres pliku”>

Adres pliku można podać na różne sposoby:

W HTML-u możemy zdefiniować wykaz numerowany i wypunktowany (nieuporządkowany)

Wykaz numerowany

<OL>

<LI> tekst pierwszego punktu </LI>

<LI> tekst drugiego punktu </LI>

…

</OL>

<OL start=20> - rozpoczęcie numerowania od liczby 20

Wykaz wypunktowany

<UL>

<LI> tekst pierwszego punktu </LI>

<LI> tekst drugiego punktu </LI>

…

</UL>

odsyłacze

Odsyłacze (linki, odnośniki, łącza) są bardzo istotnymi elementami dokumentu HTML, dzięki którym możliwe jest powiązanie między sobą dokumentów w sieci WWW.

<A HREF = ”adres strony”> tekst/obraz po którego kliknięciu uruchamia się strona </A>

Adres strony można definiować na kilka sposobów:

Na różne sposoby można też definiować „przycisk” odnośnika:

Użycie parametru target=”_blank” w znacziku <A HREF> spowoduje otwarcie strony w nowym oknie

STYLE CSS

Język HTML – definiowanie struktury tworzonej witryny internetowej oraz poszczególnych dokumentów

Język CSS – definiowanie formy prezentacji (wyświetlania) stron WWW

Najważniejsze zalety CSS:

CSS podstawowe pojęcia:

Zapis: SELEKTOR{CECHA:WARTOŚĆ;}

Przykłady:

Rodzaje stylów CSS:

<p style=”font-size: 12pt; color:blue;”>

<head>

<style type=”text/css”>

<!--

body{margin-left:1cm; margin-right:1cm;}

p{font-size:10pt; font-family: Arial, Helvetica;}

-->

</style>

</head>

obecnie formuł tych nie pisze się w znaczniku komentarza

<head>

…

<link href=”plikcss” type=”text/css” rel=”style sheet”}

…

</head>

Im styl jest zdefiniowany bliżej miejsca użycia w dokumencie tym jest ważniejszy w hierarchii formatowania. Z tego wynika, że styl lokalny ma pierwszeństwo przed zagnieżdżonym, a ten z kolei przed stylami zewnętrznymi

  1. Elementy programowania

    1. eLEMENTY PROGRAMOWANIA – WPROWADZENIE

Informatyka – dziedzina wiedzy i działalności zajmująca się gromadzeniem, przetwarzaniem i udostępnianiem informacji (czyli różnego rodzaju danych o otaczającej nas rzeczywistości).

Algorytmika – kluczowa dziedzina zajmująca się tworzeniem nowych algorytmów i ocenianiem ich poprawności

Algorytm jest przepisem rozwiązania podstawowego zadania będącego dokładnie określonym układem elementarnych

Algorytm powinien pozwalać rozwiązać problem, dla którego został opracowany w sposób automatyczny („bezmyślny”) przez inne osoby.

Algorytm bywa utożsamiany ze znaczeniami słów: metoda, sposób, recepta, przepis, program.

Formy zapisu algorytmu:

    2. schemat blokowy

Schemat blokowy jest to sieć działań czyli graficzna prezentacja algorytmu (procedury lub programu) sporządzona w celu przedstawienia algorytmu do zapisania w języku programowania. Częściami składowymi schematu blokowego są podstawowe figury geometryczne (np. prostokąt, romb, koło). W figurach tych umieszczane są proste instrukcje oraz warunki przy czym:


Elementy schematu blokowego:

Blok START wskazuje początek algorytmu. Z bloku wychodzi tylko jedna droga (strzałka).

Blok STOP wskazuje koniec algorytmu. Do bloku wchodzi tylko jedno połączenie.

W jego obrębie umieszczamy wszelkie instrukcje (obliczenia). Proces ma dokładnie jedną strzałkę wchodzącą i dokładnie jedną strzałkę wychodzącą

W bloku umieszcza się wprowadzane dane (odczyt danych). Do/z bloku wchodzi/wychodzi tylko jedno połączenie.

W bloku umieszcza się wyprowadzane wyniki (zapis danych). Do/z bloku wchodzi/wychodzi tylko jedno połączenie.

W bloku umieszcza się warunek, który decyduje o wyborze dalszej drogi postępowania. Blok ma dokładnie jedną strzałkę wchodzącą a wychodzą dwa połączenia.

Z dwóch wybranych wierzchołków rombu wyprowadza się dwie możliwe drogi:

- gdy warunek jest spełniony (etykieta "Tak") oraz

- gdy warunek nie jest spełniony (etykieta "Nie").

Symbolizuje proces, który został już wcześniej zdefiniowany (opisany).

Odpowiednik procedury, którą definiuje się raz, by następnie móc ją wielokrotnie wywołać. Podobnie jak w przypadku bloku proces i ten blok ma jedno wejście i jedno wyjście

Umożliwia łączenie dwóch miejsc by uniknąć krzyżowania strzałek - „teleportacja”.

Łączniki występują w parach (takie same etykiety).

Znaczenie podobnie jak łącznik stronicowy, lecz w obrębie co najmniej dwóch stron.

Uwaga: jeśli w schemacie stosujemy oba typy łączników, to

- najlepiej jest stosować liczby do identyfikowania jednych i litery do drugich

- lub podwójną numerację „strona / nr. łącznika” np. „3/5”

W każdym algorytmie musi się znaleźć dokładnie jeden blok START i STOP.

Przykład:

Sprawdzić, czy klient banku przekroczył dopuszczalny limit debetu na swoim koncie bankowym.

Zapis słowny algorytmu:

(Założenie: dopuszczalny limit debetu na koncie bankowym wynosi 500)

1. Początek algorytmu

2. Wprowadż stan konta i przypisz wartość za zmienną S.

3. Dodaj do stanu konta S wartość 500.

4. Sprawdzić czy wartość zmiennej S jest mniejsza od zera.

5.1. Jeżeli TAK, to wypisz komunikat „Debet..." i przejdź do 6.

5.2. W przeciwnym przypadku przejdź do 6.

6. KONIEC algorytmu

jĘZYK ALGORYTMICZNY, JĘZYK STRUKTURALNY

Język algorytmiczny – język opisu algorytmów i komunikacji między użytkownikami komputerów. Przedstawiciel klasy języków sztucznych. Większość ze stosowanych języków programowania spełnia wymagania języków algorytmicznych

Język strukturalny – umożliwia budowanie programów podzielonych na bloki, części – procedury bądź funkcje. Programowanie strukturalne ułatwia projektowanie, testowanie a także „utrzymanie” kodu programu

Tworzenie programu

Etapy tworzenia programu:

Elementy programu źródłowego:

Identyfikatory:

Struktura programu:

W każdym programie muszą wystąpić nagłówek programu i blok główny. Istotna jest kolejność umieszczania bloków w programie

nagłówek i blok główny programu

Nagłówek programu składa się ze słowa kluczowego PROGRAM, po którym umieszcza się nazwę programu (identyfikator) oraz ewentualnie ujętą w nawiasy okrągłe listę parametrów (kolejne elementy tej listy oddzielamy przecinkami). Lista parametrów może być pomijana. Nagłówek programu zakończony jest średnikiem

Blok główny programu rozpoczyna się od słowa BEGIN a zakończeniem bloku jest słowo END. (obowiązkowo z kropką). Pomiędzy tymi słowami wpisuje się instrukcje programu oraz wywołania podprogramów. Instrukcje umieszczone w programie są oddzielane od siebie średnikami

Rodzaje instrukcji i operatory

Rodzaje instrukcji:

Instrukcja przypisania to symbol dwuznakowy := i służy do przypisania zmiennej wartości i ma następującą postać:

zmienna := stała lub wyrażenie

Operatory:

+ - * / div mod

= < > <> <= >=

and Or not

Operator div oznacza dzielenie całkowite a operator mod resztę z dzielenia całkowitego

Deklaracja zmiennych

Zmienne wykorzystywane w programach muszą być wcześniej zdeklarowane (należy określić dziedzinę dopuszczalnych wartości)

Deklaracje zmiennych rozpoczynają się od słowa kluczowego VAR, po którym następuje wykaz deklaracji zmiennych

VAR

lista_identyfikatorow_1 : opis_typu;

…

lista_identyfikatorow_N : opis_typu;

Lista identyfikatorów to oddzielona przecinkami lista nazw zmiennych, a nazwa typu zawiera określenie typu zmiennej.

Typy danych:

Typy danych proste/porządkowe – są to typy, w których dla dowolnego elementu (oprócz pierwszego i ostatniego) można wskazać jego poprzednika i następcę. Do tych typów zaliczamy: zbiór liczb całkowitych, zbiór znaków i zbiór wartości logicznych

Przykład: Deklaracja zmiennych

Program nazwa_programu;

…

VAR

a: byte;

L1,L2,L3,L4: word

suma: integer;

srednia: real;

liczba_glosow: longint;

BEGIN

…

END.

Przykłady źle zdeklarowanych zmiennych:

Projektując program należy:

iNSTRUKCJA PRZYPISANIA

Instrukcja przypisania to symbol dwuznakowy := i służy do przypisania zmiennej wartości i ma następującą postać:

zmienna := stała lub wyrażenie

Przykłady:

DOBRZE ŹLE

x:=1; 1:=x;

znak := ‘A’; znak := ‘A’+’z’; ponieważ zmienna znak jest jednoznakowa

napis :=’Pelagia’; napis :=Pelagia ponieważ napisy umieszczamy w apostofach

Każda zmienna użyta w programie musi być w nim zadeklarowana

instrukcja read

read (lista_parametrów) ;

lub

readln (lista_parametrów);

Wprowadzenie do komputera wartości z klawiatury i podstawienie wczytanej wartości pod wskazaną zmienną

DOBRZE:

read (x) ;

readln (liczba 1, liczba 2);

readln (zm1,zm2,…,zmN);

ŹLE :

read (‘napis’, zm) – wolno tylko wczytać wartość i podstawić za zmienną

readln (zm+1); - nie wolno pisać wyrażeń

instrukcja WRITE

write (lista_parametrów) ; - po wyświetleniu kursor zostaje za ostatnią informacją

lub

writeln (lista_parametrów); - wyświetla i tworzy nową linię

Wyświetlenie informacji na ekranie monitora (np. tekstu, wartości zmiennej)

DOBRZE:

write (zmienna) ;

writeln (‘napis’);

writeln (‘srednia=’ , suma/(n-10));

Przykład zastosowania instrukcji prostych:

Program obliczający sumę dwóch liczb wprowadzanych przez użytkownika

Program suma_2_liczb;

Var

L1,L2,suma :intiger;

Begin

{-wprowadzenie danych-}

write(‘Podaj L1:’); readln(L1);

write(‘Podaj L2:’); readln(L2);

{-przetwarzanie danych-}

Suma := L1+L2;

{-wyprowadzanie wyników-}

Writeln (‘Wynik=’ , suma)

End.

INSTRUKCJA WARUNKOWA

Instrukcja warunkowa warunkuje wykonanie innej instrukcji pod warunkiem, że warunek będzie prawdziwy.

IF wyr_log then instrukcja_PRAWDA

ELSE instrukcja_FAŁSZ;

 IF wyr_log then instrukcja_PRAWDA;

Przykłady zastosowania instrukcji warunkowej:

Program obliczający pole koła:

Program pole_kola;

Var

promien :real;

pole:Real;

Begin

write(‘Wprowadź promień koła:’); readln(promien);

pole := 3,14*promien*promien;

IF (promien>0) then

writeln(‘Pole koła=’,pole)

ELSE

Writeln(‘Brak rozwiązania! promien<0);

End.

Program obliczającą wartość bezwzględną liczby:

Program wartość-bezwzgledna;

Var

liczba :longlnt;

Begin

write(‘Wprowadź liczbę:’); readln(liczba);

IF (liczba<0) then

Liczba := -liczba;

Writeln(‘Wartość bezw.=’,liczba);

End.

Instukcja złożona

Ciąg kilku instrukcji można zgrupować w jedną instrukcję tzw. złożoną, jeżeli poprzedzi się je słowem kluczowym „BEGIN” a zakończy słowem „END”

Przykład:

Program obliczający pole koła:

Program pole_kola;

Var

promien :real;

pole:Real;

Begin

write(‘Wprowadź promień koła:’); readln(promien);

IF (promien>0) then

Begin

pole := 3,14*promien*promien;

writeln(‘Pole koła=’,pole)

end

ELSE

Writeln(‘Brak rozwiązania! promien<0);

End.

Definiowanie stałych

Stałe definiuje się dla:

Definiowanie stałych rozpoczyna się słowem kluczowym CONST, po którym następuje wykaz identyfikatorów i wartości stałych

CONST

Identyfikator_1 = wartość;

…

Identyfikator_N = wartość;

Blok definicji stałych umieszcza się po nagłówku programu a przed blokiem głównym

Przykłady:

DOBRZE:

Pi=3.14159;

b_dobry50=5.0;

marzec=3;

X=12; Y=X;

ŹLE:

Nasze miasto=’Wrocław’; - bo spacja

X=Y=12;

instrukcje literacyjne

Instrukcje literacyjne pozwalają na powtarzanie wykonywania instrukcji bez konieczności powtarzania jej w implementacji programu (pętle)

Instrukcja repeat … until

Składnia:

REPEAT

Instrukcja

UNTIL wyrażenie_logiczne

Opis:

Powtarzaj wykonywanie instrukcji aż wartość wyrażenia logicznego będzie prawdą. Literacja typu „powtarzaj” zapewnia wykonanie instrukcji znajdującej się między repeat i until przynajmniej raz

Przykład:

Zapewnić kontrolę wprowadzanego PINU:

Program Dostep_PIN;

Const kodPIN=2905;

Var pin_we: word;

Begin

Repeat

Write (‘Wprowadź kod PIN:’);

Readln (pin_we);

Until pin_we = kodPIN;

Writeln (‘Wprowadzono poprawny PIN’);

{… dalsza część program}

End.

Zapewnić kontrolę PINU (max 3 próby):

Program Dostep_PIN_x3;

Const kodPIN=2905;

max_prob = 3;

Var pin_we: word;

proba: byte;

Begin

proba := 0;

Repeat

Write (‘Wprowadź kod PIN:’);

Readln (pin_we);

Proba := proba+1;

Until (pin_we = kodPIN) Or

(proba = max_prob);

If (pin_we <> kodPIN)

Then begin

Writeln (‘Błędny PIN’);

{…}

End

Else Begin

Writeln (‘Wprowadzono poprawny PIN’);

{… }

end

End.

Instrukcja while… do

Składnia:

WHILE

wyrażenie_logiczne

DO

Instrukcja

Opis:

Dopóki wartość wyrażenia logicznego jest prawdą wykonywana jest instrukcja po słowie DO

W szczególnym przypadku instrukcja nie zostanie wykonana nawet raz

Przykład:

Obliczyć sumę kolejnych liczb całkowitych od liczby P do liczby K podawanych przez użytkownika

Program Suma_N_liczb;’

Var

liczbaP, liczbaK: integer;

liczba_i: integer;

suma: longint;

Begin

Write (‘Podaj pierwszą liczbę’); Readln (LiczbaP);

Write (‘Podaj drugą liczbę’); Readln (LiczbaK);

Suma:=0;

Liczba_i:=liczbaP;

While (liczba_i <=liczbaK) do

Begin

Suma := suma+liczba_i;

Liczba_i := liczba_i + 1;

End

Writeln (‘Suma =’, suma);

End.

Przykład:

Napisać program do wspomagania obsługi wypłaty kredytu studenckiego. Założenia:

- łączna kwota przeznaczona w danym dniu na wypłaty nie może być większa niż 75000zł (trzos)

- liczba studentów, którym przyznano kredyt to 340 (liczbaStd)

- maksymalna kwota pojedynczego kredytu to 650zł (max_kwota)

Program Kredyt_Std;

Const

trzos = 75000;

liczbaStd = 340;

max_kwota = 650;

Var

nrStd: Word;

kwota_kred: Real;

pozyczono: Real;

Begin

Writeln(‘KREDYT…’);

pozyczono := 0;

nrStd := 1;

While (pozyczono < trzos) and (nrStd <=liczbaStd) do

Begin

Writeln (‘Kredyt dla studenta nr=’), nrStd);

Write (‘Wprowadź kwotę kredytu’); Readln (kwota_kred);

If (kwota_kred) <= max_kwota) and ((kwota_kred + pozyczono) <= trzos) then

Begin

Pozyczono := pozyczono+kwota_kred;

nrStd := nrStd+1;

end

Else

Writeln(‘Błąd: za duża kwota!!!);

Writeln (‘Pozostało:’, trzos-pozyczono:0:2);

End

End.

Instrukcja For … To oraz INSTRUKCJA for … DOWNTO

Instrukcja for .. to oraz instrukcja for … downto są prawie identyczne dlatego omawiane są razem na zasadzie porównania. Instrukcje te są tak jakby szczególnym przypadkiem wcześniej omówionych instrukcji literacyjnych dlatego nie każdą instrukcje repet czy while można zastąpić instrukcją for jednak na odwrót jest to zawsze możliwe. Instrukcję for można stosować jedynie dla zmiennych typu porządkowego (tzn. liczb całkowitych oraz znaków)

For … To … Do For … Downto … Do
Składnia

FOR zmster := wp TO wk DO

Instrukcja;

FOR zmster := wp DOWNTO wk DO

Instrukcja;
Opis

  1. Przypisz zmster wartość wp

  2. Czy zmster <= wk ?

Tak – przejdź do kroku 3

Nie – przejdź do kroku 6

  1. Wykonaj instrukcję

  2. Przypisz zmster wartość następnika

  3. Przejdź do kroku 2

  4. Koniec pętli for

  1. Przypisz zmster wartość wp

  2. Czy zmster >= wk ?

Tak – przejdź do kroku 3

Nie – przejdź do kroku 6

  1. Wykonaj instrukcję

  2. Przypisz zmster wartość poprzednika

  3. Przejdź do kroku 2

  4. Koniec pętli for
Schemat blokowy

Przykład:

Program obliczający sumę elementów tabliczki mnożenia o N wierszach i kolumnach

Program Suma_elementow;

Var

N,w,k : byte;

element : word;

suma : longint;

Begin

Repet

Write (‘Wprowadź N:’); readln (N);

Until N>0;

suma := 0;

FOR w := 1 to N do

FOR k:= 1 to N do

Begin

element := w*k;

suma := suma + element;

end;

writeln (‘Suma elementów =’ suma);

End.

Przykład:

Przykład zastosowania obu instrukcji for oraz ten sam przykład wykonany wcześniej poznanymi instrukcjami literacyjnymi.

Polecenie: Oblicz sumę liczb od -30 do 105

Wykonanie instrukcją FOR … TO … DO

Program for_to;

Var

Liczba_i : byte;

Suma: longint;

Begin

Suma := 0;

FOR liczba_i := -30 TO 105 DO

Suma := suma + Liczba_i;

Writeln (‘Suma = ‘,suma);

End.

Wykonanie instrukcją FOR … DOWNTO … DO

Program for_downto;

Var

Liczba_i : byte ;

Suma: longint;

Begin

Suma := 0;

FOR liczba_i := 105 TO -30 DO

Suma := suma + Liczba_i;

Writeln (‘Suma = ‘,suma);

End.

Wykonanie instrukcją WHILE

Program while_do;

Var

Liczba_i : byte;

Suma: longint;

Begin

Suma := 0;

Liczba_i := 30;

WHILE liczba_i <= 105 DO

Begin

Suma := suma + Liczba_i;

Liczba_i := Liczba_i + 1

End;

Writeln (‘Suma = ‘,suma);

End.

Wykonanie instrukcją REPEAT

Program repeat_until;

Var

Liczba_i : byte;

Suma: longint;

Begin

Suma := 0;

Liczba_i := 30;

REPEAT

Suma := suma + Liczba_i;

Liczba_i := Liczba_i + 1

UNTIL Liczba_i > 105;

Writeln (‘Suma = ‘,suma);

End.

Instrukcja wyboru case … of

Składnia:

Case wyr of

Lw1 : instrukcja1 ;

Lw2 : instrukcja 2;

…

LwN : instrukcjaN;

Else instrukcja_else;

End

Gdzie:

Wyr – wyrażenie typu prostego, porządkowego

Lwi – lista wartości tego samego typu co wyr

Instrukcjai – instrukcja prosta lub strukturalna

Interpretacja:

Jeżeli wartość „wyr” jest równa jednej z Lw1 to wykonaj instrukcja1 i zakończ „case”

Jeżeli nie to:

Jeżeli wartość „wyr” jest równa jednej z Lw2 to wykonaj instrukcja2 i zakończ „case”

Jeżeli nie to:

…

Jeżeli wartość „wyr” jest równa jednej z LwN to wykonaj instrukcjaN i zakończ „case”

Jeżeli nie to:

Wykonaj „instrukcja_else”

Przykład:

Wyświetlić zapis słowny oceny {5,4,3,2}

Program ocena_slownie;

Var

ocena : byte;

Begin

Write (‘Wprowadź ocene:’); Readln (ocena);

CASE ocena OF

5 : writeln (‘bardzo dobry’);

4: writeln (‘dobry’);

3 : writeln (‘dostateczny’);

2: writeln (‘niedostateczny’);

ELSE writeln (‘Co to za ocena’, ocena?);

END

End.

Przykład:

Na podstawie wprowadzonego nr. miesiąca wyświetlić nr. kwartału

Program Kwartały;

Var

Nr_miesiaca : byte;

Begin

REPEAT

Write (‘Wprowadź numer miesiąca: ‘); Readln (nr_miesiaca);

UNTIL (nr_miesiaca >=1) and (nr_miesiaca <= 12);

Write (‘Miesiąc należy do ‘);

CASE nr_miesiaca OF

1 : writeln (‘ 1 kwartału’);

2,3 : writeln (‘1 kwartału’);

4,5,6 : writeln (‘ 2 kwartału’);

7..9 : writeln (‘ 3 kwartału’);

10, 11..12 : writeln (‘ 4 kwartału’);

ELSE writeln (‘Błąd!’);

END;

End.

Tablice jedno- i wielowymiarowe

Tablice umożliwiają przechowywanie więcej niż jednej zmiennej. Tablica jest to złożona struktura danych o ustalonej liczbie składowych (elementów) tego samego typu (np. wszystkie składowe są zmiennymi typu Word). Składowe są identyfikowane za pomocą indeksu (liczba, znak, …)

Zastosowanie tablic:

Zadanie A

Napisać program, który wyliczy średnią arytmetyczną z N liczb wprowadzanych przez użytkownika

Zadanie B

Użytkownik wprowadza N liczb. Program oblicza średnią arytmetyczną tych liczb oraz wyświetla na ekranie różnicę między każdą z liczb a ich średnią arytmetyczną
Zadanie A jest trywialne i wystarczą do niego podstawowe instrukcje. W zadaniu B natomiast program musi dwa razy wykorzystać podawane zmienne (najpierw będzie obliczał średnią dla całego roku a potem odejmował tą średnią od poszczególnych liczb). Żeby to zrealizować musielibyśmy podawać programowi drugi raz te same liczby. Żeby tego uniknąć należy zastosować tablice, które umożliwiają zapamiętanie więcej niż jednej zmiennej
Tablica jednowymiarowa Przyznać nagrodę każdemu studentowi, którego średnia jest większa od średniej dla całego roku
Tablica dwuwymiarowa Przyznać nagrodę każdemu studentowi, którego średnia ocen jest większa od średniej wszystkich studentów na wydziale
Tablica trójwymiarowa Przyznać nagrodę każdemu studentowi, którego średnia ocen jest większa od średniej wszystkich studentów na uczelni

Zadanie: Przydzielić nagrodę każdemu studentowi, którego średnia ocen jest większa od średniej całego roku

Tablica średnich ocen (srednie_oceny)

4.32 3.98 4.89 3.02 2.98 … 4.10 4.33
1 2 3 4 5 … 299 300

Jak przypisujemy wartości poszczególnym komórkom tablicy? :

srednie_oceny 1 := 4.32;

srednie_oceny 5 := 2.98;

Deklaracja tablicy jednowymiarowej:

Var

Identyfikator: array [ idp .. idk ] of typ;

Gdzie:

Identyfikator – nazwa zmiennej tablicowej

idp – indeks pierwszego elementu

idk – indeks ostatniego elementu

typ – nazwa typu wartości przechowywanych w tablic

Przykłady deklaracji tablic jednowymiarowych:

DOBRZE ŹLE

liczba_ocen : array [2 .. 5] of byte;

temperature : array [-50 .. 50] of word;

licznik_liter : array [‘A’ .. ‘Z’] od word;

litera1_slowa : array [1 .. 100] of char;

zaliczono : array [false .. true] of word;

t_log : array [boolean] of real;

t_byte : array [byte] of char;

t_char : array [longint] of byte;

t_zle1 : array [10 .. 1 ] of integer;

Bo idk < idp

t_zle2 : array [2.0 .. 5.0 ] of real ;

Bo identyfikatory muszą być typu porządkowego

t_zle3 : array [1 .. 20000 ] of real ;

Za dużo zmiennych typu real (ograniczenie pamięci)

t_zle4 : array [ longint ] of byte ;

za dużo wykorzystanej pamięci

Przykłady przypisywania wartości elementom tablicy :

Zdefiniowane tablice, do których przypisujemy zmienne:

liczba_ocen : array [2 .. 5] of byte;

temperature : array [-50 .. 50] of word;

licznik_liter : array [‘A’ .. ‘Z’] od word;

litera1_slowa : array [1 .. 100] of char;

zaliczono : array [false .. true] of word;

t_log : array [boolean] of real;

t_byte : array [byte] of char;

t_char : array [longint] of byte;
DOBRZE

liczba_ocen [5] := 112;

licznik_liter [‘E’] := 55;

litera1_slowa [17] := ‘k’;

zaliczono [false] := ‘c’;

t_byte [15] := ‘@’;

t_char [‘$’] := 1178;

Przykład:

Wypełnić tablicę TAB (-10 .. 500) wartościami 0

Program Tablica1;

Var Tab : array [-10 .. 500] of word;

i : integer;

Begin

{- Pierwszy sposób-}

Tab [-10] := 0; Tab [-9] :=0; … Tab [499] :=0; Tab[500] :=0;

{-Drugi sposób-}

For i := -10 to 500 do

Tab[i] := 0;

End.

Przykład:

Przydzielić nagrodę każdemu studentowi, którego średnia ocen jest większa od zadanej np. 4.50

Program Nagroda;

Const max_studentow = 300;

Var sr_std : array [1 .. max_studentow] of real;

Sr_min : real;

nr : word;

Begin

For nr := 1 to max_studentow do

Begin

Write(‘ Wprowadź średnią studenta’, nr);

Readln (sr_std[nr]);

End;

Write(‘Wprowadź średnią’); Readln(sr_min);

For nr := 1 to max_studentow do

If sr_std [nr] > sr_min then

Writeln (‘Dla studenta nr’,nr,’nagroda’);

End.

Przykład

Przyznać nagrodę każdemu studentowi, którego średnia ocen jest większa od średniej ocen obliczonej dla całego roku

Program Nagroda;

Const max_studentow = 360;

Var sr_std : array [1 .. max_studentow] of real;

Sr_min : real;

nr : word;

suma : real;

Begin

For nr := 1 to max_studentow do

Begin

Write(‘ Wprowadź średnią studenta’, nr);

Readln (sr_std[nr]);

End;

suma :=0;

For nr := 1 to max_studentow do suma:=suma + sr_std[nr];

sr_min := suma/max_studentow;

For nr := 1 to max_studentow do

If sr_std [nr] > sr_min then

Writeln (‘Dla studenta nr’,nr,’nagroda’);

End.

Deklaracja tablicy dwu- I wielo wymiarowej:

Tablice wielowymiarowe można deklarować na dwa sposóby

Tablica dwuwymiarowa Tablica n-wymiarowa

Var

T2: array [ idp1 .. idk1 ] of

array [ idp2 .. idk2 ] of typ;

Var

T2: array [ idp1 .. idk1 ] of

…

array [ idpn .. idkn ] of typ;

Var

Identyfikator: array [idp1 .. idk1, idp2 .. idk2] of typ;

Var

Identyfikator: array [idp1 .. idk1 ,…, idpn .. idkn] of typ;

Przykłady deklaracji tablic wielowymiarowych:

Rok_oceny1 : array [1..5] of array [2..5] of Word;

Rok_oceny 2 : array [1..5,2..5] of word;

Tablica : array [‘0’..’9’, -5..12] of char;

T4 : array [1..10, Boolean, ‘A’..’Z’] of real;

Przykład przypisania zmiennych tablicowych:

Zdefiniowane tablice, do których przypisujemy zmienne:

Rok_oceny1 : array [1..5] of array [2..5] of Word;

Rok_oceny 2 : array [1..5,2..5] of word;

Tablica : array [‘0’..’9’, -5..12] of char;

T4 : array [1..10, Boolean, ‘A’..’Z’] of real;
DOBRZE

Rok_oceny1 [1][5] := 112;

Rok_oceny2 [1,5] := 112;

Tablica [ ‘6’, -3] := ‘#’;

T4 [3, true, ‘M’] := 1.65;

Przykład:

Wypełnić tablicę TAB(-5..3, 1..30) wartościami 0

Program tablica_2;

Var

Tab: array[-5..3, 1..30] of real;

Begin

{-Sposób pierwszy-}

Tab [-5,1] := 0; Tab [-5, 2]:=0; … Tab[3,29] :=0; Tab[3,30] :=0;

{-Sposób drugi-}

For w:=-5 to 3 do

For k := 1 to 30 do

Tab [w,k] :=0;

End.

definiowanie typów danych

W programie można zdefiniować własny typ danych typu:

Na zajęciach zajmujemy się tylko typem tablicowym

Definiowanie typu tablicowego

Type

Identyfikator_typu1: array [ idp .. idk ] of typ;

Identyfikator_typu2: array [ id1p .. id1k , … , idNp .. idNk] of typ;

Przykłady:

Type

tablica: array [ 1 .. 10, ’A’..’Z’] of real;

str20: string [20] ;

nazwisko: string [25] ;

Var

Tab : tablica;

Napis : str20;

Blok definicji typów danych umieszczamy w nagłówku programu, między definicją stałych a zmiennych.

Podprogramy: procedury i funkcje

Podział programu na tzw. podprogramy umożliwia:

Dostępne są dwa rodzaje podprogramów:

Podprogram do komunikacji z blokiem głównym programu lub innymi podprogramami wykorzystuje tzw. parametry


Definiowanie procedury i funkcji:

Procedure

identyfikator (lista_parametrow_formalnych);

Begin

…

End;

Function

identyfikator (lista_p_f): typ_wartości;

Begin

…

Identyfikator := wyrażenie;

End;

Gdzie:

Identyfikator –nazwa podprogramu

lista_parametrow_formalnych – oddzielone średnikami deklaracje parametrów podprogramu

Przykład:

Procedure Obliczenia (tab:tablica; var max:real);

Przykład:

Function Srednia (suma:Word; n:byte):real;

Blok definicji podprogramów umieszczamy w nagłówku programu pod blokiem definicji i deklaracji (const, type, var)

Parametrem podprogramu (procedury lub funkcji) może być wartość typu:

Zakładamy, że typy koloru niebieskie zostały wcześniej zdefiniowane w programie

Przykłady listy parametrów formalnych:

Zakładamy, że type tablica = array[1..100] of integer;

Wartość funkcji może być typu:

Zakładamy, że typy koloru niebieskie zostały wcześniej zdefiniowane w programie

Przykłady (tylko nagłówki definicji funkcji):

Gdzie:

type tablica = array[1..100] of integer;

{typy tablicowe: Ttemp, Tnazwiska}

str45 = string[45]

Przykład:

Napisać program, który dla danych X I N obliczy wartość XN.

Program Podprogramy_1;

Var

x,n,i : byte;

pom, wynik : longint;

Procedure Wprowadz_dane;

Begin

Write(‘Wprowadz X=’); Readln(X);

Write(‘Wprowadz N=’); Readln(N);

End;
Function Obliczenia (a,p: byte): longint;

Begin

pom := 1;

for I := 1 to p do

pom := pom*a;

Obliczenia := pom

End;

Begin

Wprowadz_dane;

wynik := Oblicznia (X,N);

writeln (‘Wynik =’,wynik); - wyświetli się wynik zależny od wprowadzonych liczb X,N

writeln (‘Wynik =’, Obliczenia(4,3)); - wyświetli się wynik dla X=4 i N=3 czyli 43=64

End.

Parametry formalne i aktualne:

Przykład:

procedure Nazwa_PROC (p1: byte ; var p2 : word);

function Nazwa_FUN (p1,p2: byte ; p3: word);

Przykład:

Nazwa_PROC (liczba, kwadrat_liczby);

x:=Nazwa_FUN (12, ZM, X+Y+1);

Należy pamiętać, że parametry formalne rozdzielamy średnikami a aktualne przecinkami


Parametry możemy przekazywać na dwa sposoby:

Przekazywanie parametrów przez wartość (p.wejściowy) – Jeżeli parametrem aktualnym jest zmienna, której w treści podprogramu zostanie przypisana nowa wartość, to po opuszczeniu podprogramu wartość zmiennej nie ulegnie zmianie (będzie taka sama jak przed wywołaniem programu)

Przekazywanie parametrów przez zmienną (p. wyjściowy lub wejściowo-wyjściowy) – Jeżeli parametr aktualny jest poprzedzony słowem VAR, to parametrem aktualnym musi być zmienna. W tym przypadku po zakończeniu podprogramu parametr aktualny będzie miał taką wartość jak odpowiadający mu parametr formalny w momencie zakończenia podprogramu

Przykład:

Procedure PROC (par: byte);

Begin

par := 25;

End;

{Wywołanie procedury w programie}

zm:=10;

PROC (zm);

Procedure PROC ( var par: byte);

Begin

par := 25;

End;

{Wywołanie procedury w programie}

zm:=10;

PROC (zm);
Zmienna ma na początku wartość 10 a podprogram przypisuje jej wartość 25. W przypadku przekazania parametru przez wartość (po lewej) zmienna po zakończeniu podprogramu będzie miała wartość 10. W przypadku drugim (po prawej) zmienna będzie miała wartość 25

Przykład: Napisać program, który:

Program Podprogramy_3;

Const

maxID = 100;

Type

tablica = array [1..maxID] of integer;

Var

dane1, dane2 : tablica;

ile1, ile2 : integer;

wynik : longint

Procedure Wczytaj_Dane (n:integer; var t: tablica);

Var i : integer;

Begin

For i:=1 to n do

begin

write(‘Wprowadz dane:’);

readln (t[i]);

end;

End;

Function Suma_Danych (t:tablica; n:integer) : longint;

Var i:integer;

suma:longint;

Begin

suma:=0;

for i:=1 to n do suma:=suma+t[i];

Suma_Danych:=suma;

End;

Procedure Wyswietl_Dane (t: tablica; n:integer);

Var i:integer;

Begin

Writeln(‘Liczba danych: ‘. n);

For I :=1 to n do writeln (‘D[‘, I, ’]=’, t[i]);

End;

Begin

Write(‘Wprowadz Ile1:’); Readln (ile1);

Wczytaj_Dane (ile1, Dane1);

Write(‘Wprowadz Ile2:’); Readln (ile2);

Wczytaj_Dane (ile2, Dane1);

Writeln (‘==Zestaw 1==’);

Wyswietl_Dane (Dane1, ile1);

Writeln(‘Suma danych 1= ‘, Suma_Danych(Dane1, ile1));

Writeln (‘==Zestaw 2==’);

Wyswietl_Dane (Dane2, ile2);

Writeln(‘Suma danych 2= ‘, Suma_Danych(Dane2, ile2));

End.

Definicje i deklaracje globalne oraz lokalne

Identyfikatory globalne – zdefiniowane w bloku programu. Można je wykorzystać w całym tekście programu (z wyjątkami wynikającymi z lokalności)

Program PROG;

{-identyfikatory globalne-}

Begin

…

End;

Identyfikatory lokalne –zdefiniowane w blokach stanowiących część podprogramów oraz parametry formalne. Wykorzystanie ich ograniczone jest do podprogramu, w którym zostały zdefiniowane lub zadeklarowane

Program PROC (…);

{-identyfikatory lokalne-}

Begin

…

End;

Przykład:

Program Podprogramy;

$\left. \ \begin{matrix} Const\ \ \ \ (\ldots) \\ Type\ \ \ \ \ (\ldots) \\ Var\ \ \ \ \ \ \ \ (\ldots) \\ \end{matrix} \right\}$ definicje i deklaracje globalne

Procedure Wczytaj_Dane (n:zakresID; var t: tablica);

{-Definicje i deklaracje lokalne-}

Begin

End;

Function Suma_Danych (t:tablica; n:zakresID): longint; {…}

Procedure Wyswietl_Dane (t: tablica; n:zakresID); {…}

Begin {-blok główny-}

…

End.

oBszar działania identyfikatora

Obszar działania (zasięg widoczności) identyfikatora to blok programu, w którym identyfikator jest zdefiniowany oraz wszystkie bloki wewnętrzne z wyjątkiem tych bloków wewnętrznych, w których ta sama nazwa została powtórnie zdefiniowana

Przykład:

Program PROG;

Var

x: integer;

y: boolean;

Procedure PROC;

Var

i:byte;

x:char;

Begin .. end; {np. i:=14; x:=’S’; y:=true;}

Begin … end. {np. x:=-3; y:=true;}

Przykład:

Program A

Podprogram B

Podprogram D

Podprogram C

Podprogram E
Podprogram F
Identyfikator zdefiniowany w Obszar działania identyfikatora
Program A A B C D E F
Podprogram B B D
Podprogram C C E F
Podprogram D D
Podprogram E E
Podprogram F F

Reguły związane z obszarami działania identyfikatora:

String – typ tablicowy, każdy element typu char. Wartością zmiennej napisowej może być ciąg dowolnych znaków – maksymalnie 255 elementów.

Deklaracja zmiennej napisowej:

Var

Identyfikator: string;

Przykłady:

Ograniczenie długości napisów – zmienną typu napisowego możemy ograniczyć co do ilości znaków:

Var

s1: string [25]; napis do 25 znaków

s2: string [135]; napis do 135 znaków

Wprowadzanie i wyprowadzanie wartości zmiennej - wartość zmiennej napisowej można wprowadzać za pomocą read i readln a wyprowadzać za pomocą write i writeln.

s Length(s)

‘ ‘

‘@’

‘ZIM’

‘Rok 1’

0

1

3

5

Łączenie napisów (stałych, zmiennych): operator dwuargumentowy+ lub CONCAT (arg1, arg2,…)

Funkcja LENGTH (arg) – funkcja zwracająca długość napisu; liczba znaków w ciągu stanowiącym bieżąca wartość argumentu.

Przykład: Wprowadzenie i wyświetlenie wartości napisu

Program Wyswietlanko_1;

Var

s: string;

i: byte;

Begin

Write (‘Wprowadź napis’); radln(s);

{-wersja 1-}

Writeln(‘1. Wprowadzona wartość to: ‘s);

{-wersja 2-}

Write(‘2.Wprowadzona wartość to: ‘);

For i:=1 to length(s) do

Write(s[i]);

End.
x: char UpCase(x)

‘a’

‘F’

‘3’

‘$’

‘ ‘

‘A’

‘F’

‘3’

‘$’

‘ ‘

Funkcja UpCase(arg) – zmienia znaki na wielkie

Przykład: Wprowadzony napis wyświetlić wielkimi literami

Program Wyswietlanko_2;

Var

s: string;

i: byte;

Begin

Write (‘Wprowadź napis’); radln(s);

For i:=1 to length(s) do

Write(UpCase ( s[i] ));

End.

Pascal – powtórzenie (kilka przykładów)

Przykład: Wyznaczanie wartości maksymalnej

Program Maksymalna_wartosc;

Const max_w=12; max_k=16;

Var tab:array [1..max_w, 1..max_k] of integer;

max:integer

w, k:byte;

Begin

{-wprowadzanie danych …. -}

max:=tab[1,1];

for w:=1 to max_w do

for k:=1 to max_k do

if max<tab[w,k] then max:=tab[w,k];

{-dalsza część programu-}

End.

Przykład: Ile elementów jest większych od 0

Program Liczba_elementów_dodatnich;

Const max_w=12; max_k=16;

Var tab:array [1..max_w, 1..max_k] of integer;

Ile_dodatnich:integer

w, k:byte;

Begin

{-wprowadzanie danych …. -}

Ile_dodatnich:=0;

for w:=1 to max_w do

for k:=1 to max_k do

if tab[w,k]>0 then ile_dodatnich:=ile_dodatnich+1;

{-dalsza część programu-}

End.

Przykład: Obliczyć sumę elementów macierzy

Program Suma_elementów;

Const max_w=12; max_k=16;

Var tab:array [1..max_w, 1..max_k] of integer;

suma:integer

w, k:byte;

Begin

{-wprowadzanie danych …. -}

suma:=0;

for w:=1 to max_w do

for k:=1 to max_k do

suma:= suma+ tab[w,k]

{-dalsza część programu-}

End.

Przykład: Obliczyć sumę elementów dodatnich macierzy

Program Suma_elementów_dodatnich;

Const max_w=12; max_k=16;

Var tab:array [1..max_w, 1..max_k] of integer;

suma:integer

w, k:byte;

Begin

{-wprowadzanie danych …. -}

suma:=0;

for w:=1 to max_w do

for k:=1 to max_k do

if tab[w,k]>0 then suma:= suma+ tab[w,k]

{-dalsza część programu-}

End.

  1. VISUAL bASIC FOR APPLICATIONS

    1. Wstęp

Visual Basic for Applications (VBA) to język programowania dołączony do wielu aplikacji pracujących pod kontrolą systemu Microsoft Windows. Zalicza się do nich:

Prawie identyczny jest interfejs języka, składnia, takie same słowa kluczowe i instrukcje. Różnice sprowadzają się do różnych obiektów (ich metod, właściwości) związanych z aplikacją macierzystą.

Makro – akcja lub zestaw akcji (instrukcji), które można użyć do automatyzacji zadań

FUNKCJA VS FORMUŁA

VBA pozwala na tworzenie nowych funkcji, nie będących częścią Excela bądź na zapisanie tych funkcji w czytelniejszy sposób. Porównamy więc czytelność funkcji a formuły w VBA na przykładzie zagnieżdżonej instrukcji warunkowej.

Przykład:

Przyznanie pracownikowi premii w zależności od zajmowanego stanowiska

Stanowisko Premia (procent pensji)
1 10%
2 9%
3 7%
Pozostali 0%

Funkcja w Excelu:

= jeżeli(stanowisko=1;pensja*0,1; jeżeli (stanowisko=2;pensja*0,09; jeżeli (stanowisko=3;pensja*0,07;0)))

Formuła w VBA:

Function Premia (stanowisko, pensja)

If stanowisko = 1 Then

Premia = pensja*0,1

Elseif stanowisko = 2 Then

Premia = pensja*0,09

Elseif stanowisko = 3 Then

Premia = pensja*0,07

Else

Premia = 0

End If

End Function

DEKLARACJE STAŁYCH I ZMIENNYCH ORAZ TYPY DANYCH

Deklaracja stałych:

Const stała = wartość

Przykłady:

Const Str1 = „Napis”

Const liczba1 = 5

Const Str2 = „Napis”, Liczba2 = 3,4567

Typy danych:

PASCAL VBA Rozmiar
Boolean Boolean 1 byte
String String Więcej niż 256 bytes
Byte Byte 1 byte
Integer Integer 2 bytes
Longint Long 4 bytes

Real

Single

Double

Single

(single-precision floating-point)

 4 bytes

Double

(double-precision floating-point)

 8 bytes

Deklaracja zmiennych:

Dim zmienna As typ_danych

Przykłady:

Dim liczba As Integer

Dim x,y As Boolean, z As long - zmienna z traktowana jest jako zmienna nieokreślonego typu

Dim Liczba2, inna_wartosc - obie zmienne traktowane są jako zmienne nieokreślonego typu

Dim str30 As String*30

Przykłady deklaracji tablicy:

Dim Tablica(50) - 51 elementów, pierwszy o indeksie 0

Dim Szachy(8,8) As Integer

Dim Macierz3(1 to 5, 4 to 9, 3 to 5) As Byte

Dim InnaMacierz()

INSTRUKCJE WEJŚCIA/WYJŚCIA

W Pascalu instrukcje wejścia I wyjścia to write lub writeln oraz read i readln

W VBA instrukcje te nieco się różnią:

InputBox (Pytanie [,Tytuł][,Domyślny tekst] [,XPos] [, YPos] [,PlikHelp, idxHelp])
MsgBox (Komunikat [,Przyciski] [,Tytuł] [,PlikHelp, idxHelp])

Elementy w nawiasach kwadratowych nie są wymagane. Są to elementy dodatkowe.

Pytanie – tekst wyświetlany w oknie dialogowym

Przyciski – przyciski określone za pomocą tekstu bądź numeru

Tytuł – tytuł okna wyświetlany w belce tytułowej

PlikHelp – plik pomocy wyświetlany, gdy użytkownik naciśnie IdxHelp w oknie dialogowym

Przykłady:

napis =InputBox( „Wprowadź liczbę”, „Okno wprowadzania”, „1”, 100, 100, „DEMO.HLP”, 10)

klawisz = MsgBox(„Czy chcesz kontynuować?” , vbYesNo + vbCritical + vbDefaultButton2, „Pytanie”, „DEMO.HLP”, 10)

iNSTRUKCJE WARUNKOWE

W Pascalu poznaliśmy dwie instrukcje warunkowe: If oraz Case. W VBA jest podobnie:

If warunek Then

Instrukcja

ElseIf warunek Then

Instrukcja

…

Else

Instrukcja

End If

Select Case wyrażenie

Case lista_wartości1

Instrukcje…

…

Case lista_wartościN

Instrukcje…

Case Else

Instrukcje_else …

End Select

INSTRUKCJE LITERACYJNE

W VBA tak jak i w Pascalu mamy instrukcje While, Repeat i for z drobnymi różnicami:

While warunek

Instrukcje

Wend

For zm = wp To wk [Step krok]

Instrukcje

Next [zm]

Do (While|Until) warunek

Instrukcje

Loop

Do

Instrukcje

Loop (While | Until) warunek

Podprogramy

W VBA odpowiednikiem procedury jest Sub a odpowiednik funkcji jest taki sam (function)

Procedura:

Sub identyfikator (parametry)

…

End Sub

Funkcja:

Function identyfikator (paramtetry) As typ_wartości

…

End Function

Przekazywanie parametrów

  1. przekazywanie parametru przez wartość

ByVal zmienna As typ_danych

  1. przekazywanie parametru przez zmienną

ByRef zmienna AS typ_danych

zmienna As typ_danych bo automatycznie jest przez zmienną

Przykład:

Sub Proc(arg1 as byte, ByVal arg2 as Integer, ByRef arg3 as string)

Call identyfikator_procedury (parametry)

ADRESY – ODWOŁANIA DO KOMÓREK

Cells(2,3).Value = wartość

Range(„C2”).Value = wartość

zm=Workbooks(„Plik”).Sheets(„Arkusz1”).Range(„A1:D5”).Value

Range (“A1”) Komórka A1
Range (“A1:B5”) Komórki od A1 do B5
Range (“C5:D9, G9:H16”) Wybór kilku obszarów
Range (“A:A”) Kolumna A
Range (“1:1”) Wiersz 1
Range (“A:C”) Kolumny od A do C
Range (“1:5”) Wiersze od 1 do 5
Range (“1:1, 3:3, 8:8”) Wiersze 1, 3 i 8
Range (“A:A, C:C, F:F”) Kolumny a, c i f

znaki specjalne

” ” Wartość napisowa
‘ Rozpoczęcie komentarza w wierszu
_ Łącznik wiersza podzielonego na kilka lini
& Łącznik tekstu i wartości numerycznej

Zasięg widoczności identyfikatorów (publiczne/prywatne)

Option Explicit

Const stała = wartość ‘ lokalna stała (bo domyślnie jest Private)

Public Const stała = wartość

Private Const stała = wartość

Dim zmienna As typ danych ‘ lokalna zmienna (bo domyślnie jest Private)

Public zmienna As typ danych

Private zmienna As typ danych

[Public/Private] Sub identyfikator (parametry)

….

End Sub

[Public/Private] Function identyfikator (parametry) As typ_danych

….

End Function

Napisy – funkcje vba

Len (s As String) As Long

długość napisu s; liczba znaków w ciągu stanowiącym bieżącą wartość argumentu.

Left (s As String, ile As Byte) As String

Pierwsze ile znaków licząc od początku ciągu tekstowego s.

Mid (s As String, od_znaku As Byte, ile_znaków As Byte) As String

Napis składający się z określonej liczby znaków (ile_znaków) napisu s począwszy od wskazanego przez od_znaku.

Right (s As String, ile_znaków As Byte) As String

Napis składający się z określonej liczby znaków napisu s licząc od końca tego napisu.

UCase (s As String) As String

napis s po dokonaniu w nim konwersji wszystkich małych liter na wielkie.

LCase (s As String) As String

napis s po dokonaniu w nim konwersji wszystkich wielkich liter na małe.


Wyszukiwarka